Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons

++- 1M. BENJELLOUN : 2005-06 Info II

Mohammed BENJELLOUN

Service d’Informatique

Faculté Polytechnique de Mons

[email protected]

2005-2006

Programmation en


#include …

void fonct (int a){ a=1 ;}

void main(void){ int var = 5; fonct (var); cout << var ;}

5

#include …

int fonct (int a){ a=1 ; return a;}

void main(void){ int var = 5; var = fonct (var); cout << var;}

1

#include …

void fonct (int &a){ a=1 ;}

void main(void){ int var = 5; fonct (var); cout << var ;}

1

#include …

void fonct (int *a){ *a=1 ;}

void main(void){ int var = 5; fonct (&var); cout << var ;}

1

Appel par valeurs, pointeurs, références ??!!


Déclaration d'une structure comportant Déclaration d'une structure comportant des fonctions membres des fonctions membres

struct point{ int x ; int y ;} ;

• initialise pour attribuer des valeurs aux "coordonnées" d'un point ;• deplace pour modifier les coordonnées d'un point ;• affiche pour afficher un point .Voici comment nous pourrions déclarer notre structure point :

Supposons que nous souhaitions associer à la structure trois fonctions :

struct point{int x ; // déclaration "classique" des données int y ; // déclaration des fonctions membre (méthodes) void initialise (int, int) ;void deplace (int, int) ;void affiche () ;} ;


// Définition des fonctions membres du type point

#include <iostream>using namespace std ;

void point::initialise (int abs, int ord){x = abs ; y = ord ;}

void point::deplace (int dx, int dy){x += dx ; y += dy ;}

void point::affiche (){cout << "Je suis en " << x << " " << y << "\n" ;}

Définition des fonctions membres

point::initialise

opérateur de "résolution de portée"

Il signifie que l'identificateur initialise concerné est celui défini dans point. En l'absence de ce "préfixe" (point::), nous définirions effectivement une fonction nommée initialise(), mais celle-ci ne serait plus associée à point ; il s'agirait d'une fonction "ordinaire" nommée initialise, et non plus de la fonction membre initialise de la structure point.

struct point { int x , y;

void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;


void main(){ point a, b ;

// on peut accéder aux "membre " avec . a.initialise (5, 2) ; a.affiche () ; a.deplace (-2, 4) ; a.affiche () ; b.initialise (1,-1) ; b.affiche () ;}

Je suis en 5 2 Je suis en 3 6 Je suis en 1 -1


void point::affiche (){cout << "Je suis en " << x << " " << y << "\n" ;}

struct point{int x, y ; void initialise (int, int) ;void deplace (int, int) ;void affiche () ;} ;


Objet et classe Le fondement de la programmation orientée objet (POO) est de pouvoir protéger

certaines données d’une structure, d’où la nécessité des classes.La notion de classe donne en fait la Définition d'un objet.

En C++ la structure est un cas particulier de la classe. Plus précisément, une classe sera une structure dans laquelle seulement certains membres et/ou fonctions membres seront "publics", c'est-à-dire accessibles "de l'extérieur", les autres membres étant dits "privés".


struct Client{ // Données membres string Nom, Prenom; int Solde; // Déclaration fonctions membres

void Saisir ();void Afficher ();bool Etat_Client();

};

class Client{ private: // Données membres string Nom, Prenom; int Solde; public:

// Déclaration fonctions membresvoid Saisir ();void Afficher ();bool Etat_Client();

};

Cachées auxfonctions externes

Accessibles depuisl'extérieur de la classe

La déclaration d'une classe est voisine de celle d'une structure. Il suffit de:• remplacer le mot clé struct par le mot clé class,• préciser quels sont les membres publics (fonctions ou données) et les membres privés en utilisant les mots clés public et private.

Définition d'une classe

Encapsulation

(masquage des données)(masquage des données)


Que signifient public, private et protected ?

Un membre déclaré publicpublic dans une classe peut être accédé par toutes les autres classes et fonctions. Un membre déclaré privateprivate dans une classe ne peut être accédé que par les autres membres de cette même classe.

Un membre déclaré protected protected dans une classe ne peut être accédé que par les autres membres de cette même classe ainsi que par les membres des classes dérivées.


Un membre public d'une classe peut être accédé partout où il est visible ; un membre privé ne peut être accédé que depuis une fonction membre de la classe .

class point{ private : // déclaration des membres privés int x ; int y ; public : // déclaration des membres publics void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;

class point{ int x ; int y ; public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;



Un objetUn objet Un objetUn objet est donc une instanciation d’une classe. est donc une instanciation d’une classe.

Cet objet possède tous les attributs et toutes les Cet objet possède tous les attributs et toutes les fonctions membres de la classe, mais avec des fonctions membres de la classe, mais avec des valeurs d’attributs propres à l’objet. valeurs d’attributs propres à l’objet.

class Liste{public: int i; string nom; Liste *Suiv; void AffListe(void);};

// pointeur sur le premier élément de la liste Liste *debut=new Liste;

void main(){ point a, b ;…


void main(){ point a, b ; // 2 objets de type point

// on peut accéder aux "membre public" avec . a.initialise (5, 2) ; a.affiche () ; a.deplace (-2, 4) ; a.affiche () ; b.initialise (1,-1) ; b.affiche () ;}

Je suis en 5 2 Je suis en 3 6 Je suis en 1 -1


Les mots clés public et private peuvent apparaître à plusieurs reprises dans la définition d'une classe, comme dans cet exemple :class X{ private :...public :...private :...} ;

Si l'on rend publics tous les membres d'une classe, on obtient l'équivalent d'une structure. Ainsi, ces deux déclarations définissent le même type point :struct point class point{ int x ; { public : int y ; int x ; void initialise (...) ; int y ;..... void initialise (...) ;} ; .. .. } ;


class point{ int x ; int y ; public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;


class point{ int x ; int y ; public :

void initialise (int abs, int ord){ x = abs ; y = ord ; }

void deplace (int, int) ; void affiche () ;} ;

meilleure lisibilité du programme.


#include <iostream>using namespace std;class CRec { public: int Long; int Larg; };void main(){ CRec Rc1, Rc2; int Surface = 0; Rc1.Long = 30; Rc1.Larg = 24; Rc2.Long = Rc1.Long/2; Rc2.Larg = Rc1.Larg*2; Surface = Rc1.Long * Rc1.Larg; cout << endl << "Surface rectangle 1 = " << Surface; cout << endl << " Surface rectangle 2 = " << Rc2.Long * Rc2.Larg;}

#include <iostream>using namespace std;class CRec { public: int Long; int Larg; int CalcSurf() { return (Long*Larg); }};void main(){ CRec Rc1, Rc2; int Surface = 0; Rc1.Long = 30; Rc1.Larg = 24; Rc2.Long = Rc1.Long/2; Rc2.Larg = Rc1.Larg*2; Surface = Rc1.CalcSurf(); cout << endl << "Surface rectangle 1 = " << Surface; cout << endl << " Surface rectangle 2 = " << Rc2.CalcSurf();}


class Etudiant {string Nom;int AnEtud;int Note;

public : void saisieEtud(); void afficherEtud(); };

class Direction { string Titre; string Nom;

public : void FonctDir();};

void Direction : :FonctDir(){ Direction B; Etudiant A;

Titre = "Doyen"; // OK B.Titre ="Recteur"; // OK

Note = 50; // Not OK A.Note = 70; // Not OK};

friend Direction;

OK


#include <iostream>#include <string>using namespace std ;

class Copain;

class Qui { string LeNom;

public: void sonnom(string n) { LeNom=n; } friend Copain; // Les fonctions membres de la classe Copain ont ainsi accès // aux attributs privés de la classe Qui.};

class Copain { string nom;

public: void sonnom(string n) { nom=n; } void moi() { cout << nom << " "; } void monami(Qui &q) { cout << q. LeNom << " "; // accès au membre private de Qui

// si pas de friend Copain; dans Qui // cannot access private member declared in class 'Qui'

}};

void main() { Qui QQui; Copain Cop;

QQui.sonnom("Laurel"); Cop.sonnom("Hardy");

Cop.moi(); cout << "est l'ami de "; Cop.monami(QQui); cout << endl;}

Hardy est l'ami de Laurel

friendfriendClasse amieClasse amie


Un constructeur est une fonction membre d’initialisation (définie comme les autres fonctions membres) qui sera exécutée automatiquement à chaque création d'un objet. Le constructeur : porte le nom de sa classe, définit l'initialisation d'une instance, appelé implicitement à toute création d'instance, ne peut retourner aucune valeur, (fonction membre non typée même pas void ), peut admettre des arguments qui sont en fait les valeurs d’initialisation des différents champs de la variable.

Constructeur et destructeur

Il peut y avoir autant de constructeurs que l’on veut (tant qu’ils diffèrent par leur nombre et types d’arguments), ce qui est très intéressant pour initialiser les variables avec différents types; mais il n’y a qu’un seul destructeur par classe !

class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point (int, int) ; // constructeur point (float, float) ; // constructeur point () ; // constructeur} ;


De même, le destructeur est une fonction membre appelée automatiquement au moment de la destruction de l'objet, il :

porte le nom de sa classe précédé d'un tilde (~), n'a pas de type de retour (même pas void), définit la "désinitialisation" d'une instance, appelé implicitement à toute disparition d'instance, fonction membre non typée et sans paramètre.

mais il n’y a qu’un seul destructeur par classe !

class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point () ; // constructeur ~ point (); //prototype du destructeur } ;

point ::point () {cout << "In constructeur \n" ;x=0; y = 0;}

point :: ~ point () {cout << "In destructeur \n" ;x=0; y = 0;}


Constructeurs par défautConstructeurs par défaut

Point::Point()Point::Point(){{ X = 0;X = 0; Y = 0;Y = 0;}}

Par définition, le constructeur par défaut est : A::A(); // Avec aucun paramètre ! Rôle : il crée une instance non initialisée quand aucun autre constructeur fourni n’est applicable.

void Etudiant::Etudiant(){saisie();cout<< "Entrer NumCarte"<<" ";cin>>NumCarte;cout<<"Entrer AnEtud"<<" ";cin>>AnEtud;for (int i=0; i<3; i++){

cout << "\nNote["<<i<<"] =";cin >> Note[i];

}};


Comment concevoir le type de classe CLAS de façon que ce programme :

void main() {CLAS x;cout << " Salut \n" ;}

Fournisse les résultats suivants :Creation Objet SalutDestruction Objet.

CLAS :: CLAS () {cout << "Creation Objet \n" ;}

CLAS :: ~ CLAS () {cout << "Destruction Objet \n" ;}


Constructeurs par paramètresConstructeurs par paramètres

Tab:: Tab ( int taille ) // Constructeur{TabElement = new TElement [taille] ;}Tab ::~ Tab () // Destructeur{delete [] TabElement ;}

class CRec { public: int Long; int Larg; CRec( int Lo, int La){ Long = Lo; Larg = La; }};


class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point () ; // constructeur ~ point (); //prototype du destructeur } ;

La déclaration suivante convient-elle toujours ?

point a ;

à partir du moment où un constructeur est défini, il doit pouvoir être appelé (automatiquement) lors de la création de l'objet a. Ici (Ex2), le constructeur a besoin de deux arguments.Ceux-ci doivent obligatoirement être fournis dans notre déclaration, par exemple : point a(2,5) ;

Ex1

class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point (int, int) ; // constructeur ~ point (); //prototype du destructeur } ;

Ex2


class x { int i,j ;public: x(int , int ) ;} ;

x::x(int a,int b) {...}

void main(void) { x vx1(2,3) ; // ok x vx1= x(3,5) ; // ok x vx ; // déclenche une erreur de compilation.

...Le programme ci-dessus déclenche une erreur car à la déclaration de la variable vx, le compilateur recherche une fonction sans paramètres.


#include <iostream>using namespace std;class CRec { public: int Long, Larg; CRec (int Lo, int La){ cout << “In Constructeur Param“<< endl ; Long = Lo; Larg = La; }

CRec (){ cout << “In Constructeur 0“<< endl ; }

int CalcSurf() { return (Long*Larg); }};

void main(){ CRec Rc1(10,20), Rc2, Rc3; int Surface = 0; Surface = Rc1.CalcSurf(); cout << endl << "Surface rectangle 1 = " << Surface;

cout << endl << " Surface rectangle 2 = " << Rc2.CalcSurf();

Rc3.Long = 30; Rc3.Larg = 24;

cout << endl << " Surface rectangle 3 = " << Rc3.CalcSurf();}

In Constructeur ParamIn Constructeur 0In Constructeur 0

Surface rectangle 1 = 200 Surface rectangle 2 = 687194768 Surface rectangle 3 = 720

Initialisation et affectation Initialisation et affectation


#include <iostream>using namespace std;class CRec { int Long, Larg; public: CRec (int Lo, int La){ cout << “In Constructeur Param“<< endl ; Long = Lo; Larg = La; }

CRec (){ cout << “In Constructeur 0“<< endl ; }

int CalcSurf() { return (Long*Larg); }};

void main(){ CRec Rc1(10,20), Rc2, Rc3; int Surface = 0; Surface = Rc1.CalcSurf(); cout << endl << "Surface rectangle 1 = " << Surface;

cout << endl << " Surface rectangle 2 = " << Rc2.CalcSurf();

Rc3.Long = 30; Rc3.Larg = 24;

cout << endl << " Surface rectangle 2 = " << Rc3.CalcSurf();}

private:

Erreur

Initialisation et affectation Initialisation et affectation

error C2248: 'Long' : cannot access private member declared in class 'CRec'


Constructeurs par défaut et par Constructeurs par défaut et par paramètresparamètres

Un constructeur par défaut et par paramètres : Un constructeur par défaut et par paramètres : Constructeur possédant des paramètres avec des valeurs de Constructeur possédant des paramètres avec des valeurs de défaut.défaut.

class CRec { int Long; int Larg; public: CRec( int Lo=0, int La=0){ Long = Lo; Larg = La; }};

CRec X; // OKCRec Y(1); // OKCRec Z(1,2); // OK

constructeur I (0, 1 ou 2 arguments)


#include <iostream>using namespace std ; // création d'un patron de fonctionstemplate <class T> T min (T a, T b){ if (a < b) return a ; // ou return a < b ? a : b ; else return b ;}

void main(){ int n=4, p=12 ; float x=2.5, y=3.25 ; char a='A', b='B';

cout << "min (n, p) = " << min (n, p) << "\n" ; // int min(int, int) cout << "min (x, y) = " << min (x, y) << "\n" ; // float min (float, float) cout << "min (a, b) = " << min (a, b) << "\n" ; // char min (char, char)}

patron de patron de fonctionsfonctions

min (n, p) = 4min (x, y) = 2.5min (a, b) = A


template<class T> void swap(T& x, T& y) { T tmp = x; x = y; y = tmp; }

void main() { int i,j; /*...*/ swap(i,j); // Instancie swap pour int float a,b; /*...*/ swap(a,b); // Instancie swap pour float char c,d; /*...*/ swap(c,d); // Instancie swap pour char string s,t; /*...*/ swap(s,t); // Instancie swap pour String }


#include <iostream>#include <string>using namespace std ; // création d'un patron de classe

template <class T> class point { T x ; T y ; public : point (T abs=0, T ord=0) { x = abs ; y = ord ; } void affiche () ;} ;template <class T> void point<T>::affiche () { cout << "Paire : " << x << " " << y << "\n" ;}

void main (){ point <int> ai (3, 5) ; ai.affiche () ; point <char> ac ('d', 'y') ; ac.affiche () ; point <double> ad (3.5, 2.3) ; ad.affiche () ; point <string> as ("Salut", " A vous") ; as.affiche () ;}

patron de classepatron de classe

T prend la valeur int pour la classe point

Paire : 3 5Paire : d yPaire : 3.5 2.3Paire : Salut A vous


La réutilisationLa réutilisation

L'héritage est un principe propre à la programmation orientée objet, L'héritage est un principe propre à la programmation orientée objet, permettant de créer une nouvelle classe à partir d'une classe existante. permettant de créer une nouvelle classe à partir d'une classe existante.

L’héritageL’héritage

Il est possible de représenter sous forme de hiérarchie de classes, parfois appelée arborescence de classes, la relation de parenté qui existe entre les différentes classes. L'arborescence commence par une classe générale appelée superclasse (parfois classe de base, classe parent, classe mère ou père). Puis les classes dérivées (classe fille ou sous-classe) deviennent de plus en plus spécialisées. Ainsi, on peut généralement exprimer la relation qui lie une classe fille à sa mère par la phrase "est un" .

Un omnivore est un animal mais pas forcement l’inverse

Permet l’extension d'une classe de base afin de lui ajouter des fonctionnalités particulières tout en conservant les fonctionnalités déjà définies dans la classe de base.


Principe de l’héritagePrincipe de l’héritage• Les classes dérivées sont un mécanisme simple pour définir une nouvelle

classe en ajoutant des facilités à une classe existante sans reprogrammer ou recompiler la classe de base.

• On peut ainsi utiliser l’héritage pour les besoins de généralisation, de réutilisation.

• La classe dérivée hérite des attributs et des fonctions de la classe de base.

• La classe dérivée est plus spécifique que la classe en ajoutant des attributs et des fonctions membres.

class Personne {string nom, prenom;

public :void saisie();void afficher();

};

class Etudiant : public Personne{int NumCarte;int AnEtud;int Note[3];

public : friend Direction;Etudiant *suiv;void saisieEtud();void afficherEtud();

};


En C++, il existe En C++, il existe l’héritage simplel’héritage simple, et , et l’héritage multiplel’héritage multiple. Dans ce . Dans ce cours, nous ne nous intéresserons qu’à l’héritage simple.cours, nous ne nous intéresserons qu’à l’héritage simple.

Dans la définition de la classe dérivée, afin d’utiliser l’héritage, on Dans la définition de la classe dérivée, afin d’utiliser l’héritage, on ajoute le symbole ajoute le symbole :: après le nom de la classe en précisant par la suite après le nom de la classe en précisant par la suite quelle est la classe de base.quelle est la classe de base.

Ex:Ex:class ClasseDeriveeclass ClasseDerivee :: public public ClasseBaseClasseBase {...}{...} class Vehicule { … };

class voiture : public Vehicule { public: // ... };

On mentionne cette relation de plusieurs manières:•voiture est une sorte de Vehicule •voiture est "dérivée de" Vehicule •voiture est un Vehicule spécialisé. •voiture est une "sous-classe" de Vehicule •Vehicule est une "classe de base" de voiture •Vehicule est la "superclasse" de voiture

class Personne { public: Personne(string nom){…} …};

class Travailleur : public Personne { public: …};

class Employeur : public Personne { ...};..


Mode de dérivationMode de dérivation

Lors de la définition de la classe dérivée il est possible de spécifier le mode de dérivation par l'emploi d'un des mots-clé suivants : public, protected ou private.

Ce mode de dérivation détermine quels membres de la classe de base sont accessibles dans la classe dérivée.

Par défaut, le type d’héritage est privé (par défaut le mot-clé private.)

Les membres privés de la classe de base ne sont jamais accessibles par les membres des classes dérivées.

class ClasseDeriveeclass ClasseDerivee : : ModeMode ClasseBaseClasseBase {...}{...}


class CptBanque {

int ident; float solde;

public:

CptBanque(int id, float so = 0);

void deposer(float);

void retirer(float);

float getSolde();

};

class CptPlus : public public CptBanque {

float prelev;

public:

void prelever();

CptPlus(int id, float pr, float so);

};

La classe CptPlus est un CptBanque avec de nouvelles fonctionnalités (un prélèvement automatique). Elle hérite des champs et méthodes de CptBanque et possède en plus un champ prelev et de la méthode prelever. Qualifier la classe CptPlus comme héritant public de CptBanque, signifie que tous les champs et méthodes public de la classe CompteBanque (classe de base) sont définis implicitement public dans la classe ComptePrelevementAuto (classe dérivée public).

héritage simple public héritage simple public

Héritage Héritage PublicPublic: Les types d’attributs: Les types d’attributsC'est la forme la plus courante d'héritage C'est la forme la plus courante d'héritage


Héritage Public: Les types d’attributsHéritage Public: Les types d’attributsC'est la forme la plus courante d'héritage C'est la forme la plus courante d'héritage

Classe de base Classe dérivée

private private

protected protected

public public

Les attributs Les attributs privateprivate, , protectedprotected et et publicpublic de la classe de base restent les mêmes de la classe de base restent les mêmes pour la classe dérivée.pour la classe dérivée.

Le type d’attribut protected est Le type d’attribut protected est le plus utilisé lors de l’héritage.le plus utilisé lors de l’héritage.

class ClasseDerivee : class ClasseDerivee : publicpublic ClasseBaseClasseBase

class Vehicule { public: void pub1(); protected: void prot1(); private: void priv1();};class Voiture : public Vehicule { public: int pub2() { pub1(); // OK prot1(); // OK priv1(); // ERREUR }};Voiture X;X.pub1(); // OK X.pub2(); // OK

protégés (protected), c'est à dire accessibles aux membres de la classe et ses classes dérivées (par héritage);


REDEFINITION DE METHODES DANS LA CLASSE DERIVEEREDEFINITION DE METHODES DANS LA CLASSE DERIVEE

Les méthodes (fonctions, …) de la classe de base peuvent être redéfinies Les méthodes (fonctions, …) de la classe de base peuvent être redéfinies dans la classe dérivée (dans la classe dérivée (le même nom que dans la classe de base)le même nom que dans la classe de base). Elles . Elles demeurent accessibles via l'opérateur de résolution de portée ("::").demeurent accessibles via l'opérateur de résolution de portée ("::").

#include <iostream>using namespace std;

class X { public: void f1(){ cout << "\n In F1 X"; } void f2(){ cout << "\n In F2 X"; } protected: int K;};

class Y : public X { public: void f2() { cout << "\n In F2 Y"; } void f3();};

void Y::f3() { f1(); // appel de f1 de la classe X f2(); // appel de f2 de la classe Y X::f2(); // f2 de la classe X X::K = 5; // accès au membre K de la classe X

cout << "\n In F3 K =" << k; K = 14; // accès au membre K de la classe X

cout << "\n In F3 K =" << K;}

void main() { X A; Y B; A.f2(); B.f3(); }

In F2 X In F1 X In F2 Y In F2 X In F3 K =5 In F3 K =14


/* --- Déclaration et définition de la classe pointcol ----- */class pointcol : public point // pointcol dérive de point{ int couleur ; public : void colore (int cl) { couleur = cl; cout << "\n couleur = " << couleur << "\n" ; }} ;

void main(){ pointcol p ; p.initialise (10,20) ; p.colore (5) ; p.affiche () ; p.deplace (2,4) ; p.affiche () ;}


// ------------ Déclaration de la classe point class point{ /* déclaration des membres privés */ private : int x ; int y ; /* déclaration des membres publics */ public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;

//Définition des fonctions membres de la classe point void point::initialise (int abs, int ord){ x = abs ; y = ord ;}void point::deplace (int dx, int dy){ x = x + dx ; y = y + dy ;}void point::affiche (){ cout << "Je suis en " << x << " " << y << "\n" ;}Les membres publics de la classe de base (point)

seront des membres publics de la classe dérivée (pointcol).

couleur = 5Je suis en 10 20Je suis en 12 24


class pointcol : public point // pointcol dérive de point{ int couleur ; public : void colore (int cl) { couleur = cl; cout << "\n couleur = " << couleur << "\n" ; }} ;

void main(){ point A; pointcol B;

A.initialise (5,10); A.affiche () ;

B.initialise (20,30); B.affiche () ;

A=B;

A.affiche () ; B.affiche () ;}


class point{ /* déclaration des membres privés */ private : int x ; int y ; /* déclaration des membres publics */ public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;

void point::initialise (int abs, int ord){ x = abs ; y = ord ;}void point::deplace (int dx, int dy){ x = x + dx ; y = y + dy ;}void point::affiche (){ cout << "Je suis en " << x << " " << y << "\n" ;}

Je suis en 5 10Je suis en 20 30Je suis en 20 30Je suis en 20 30

Conversions automatiques : si B hérite de A, alors toutes les instances de B sont aussi des instances de A, et il est donc possible de faire : A a; B b; a=b;


#include <iostream>#include "point.hpoint.h" /* déclaration de la classe point (nécessaire */ /* pour compiler la définition de pointcol) */using namespace std ;

class pointcol : public point { int couleur ; public : void colore (int cl) { couleur = cl ; } void affichec () ; void initialisec (int, int, int) ;} ;

void pointcol::affichec (){ affiche () ; cout << " et ma couleur est : " << couleur << "\n" ;}

void pointcol::initialisec (int abs, int ord, int cl){ initialise (abs, ord) ; couleur = cl ;}

void main(){ pointcol p ; p.initialisec (10,20, 5) ; p.affichec () ; p.affiche () ; p.deplace (2,4) ; p.affichec () ; p.colore (2) ; p.affichec () ;}

Utilisation de pointcol

Je suis en 10 20 et ma couleur est : 5Je suis en 10 20Je suis en 12 24 et ma couleur est : 5Je suis en 12 24 et ma couleur est : 2


class Personne {string nom, prenom;

public :void saisie();void afficher();string Lenom();string Leprenom();

};

class Etudiant : public Personne{int NumCarte;int AnEtud;int Note[3];

public : friend Direction;Etudiant *suiv;void saisie();void afficher();

// void saisieEtud();// void afficherEtud();};

class Prof : public Personne{string Service;float Salaire;

public :void saisie();void afficher();Prof *suiv;

};

class Direction : public Prof{string Titre;

public : void saisieDir(); void afficherDir();

void moyenne(Etudiant *Tete);};


void main (void){Etudiant *debET= NULL;Prof *debProf= NULL;Direction D;

int choix =1;string chrch;

do{ choix= menu(); switch (choix){

case 1: cout<<"Saisie Etudiants :"<<endl; debET = insereTete(debET); affichage(debET); break;

case 2: cout<<"Saisie Profs :"<<endl; debProf = insereTete(debProf); affichage(debProf); break;

case 3: cout<<"Doyen Calcul Moyenne :"<<endl; D.moyenne(debET); break;

case 4 : cout << "\n Prof a chercher nom ? : "; cin >> chrch; if (Tposition(chrch, debProf) == -1) cout << "Le "<< chrch <<" n'est pas dans la liste \n\n"; break;

…


Qu'est ce que la "STL"?

La STL ("Standard Templates Library") est une librairie qui est constituée principalement par des classes containers (Conteneurs :collections d'objets ; très efficace), ainsi que des fonctionnalités pour parcourir (iterator) leur contenu et des algorithmes pour travailler sur leur contenu.

STL : C++ AlgorithmsC++ VectorsC++ Double-Ended QueuesC++ ListsC++ Priority QueuesC++ QueuesC++ Stacks C++ SetsC++ MultisetsC++ MapsC++ Multimaps C++ Bitsets Iterators

STLSTL


C++ Lists :Container constructors create lists and initialize them with some data

Container operators assign and compare lists

assign assign elements to a list

begin returns an iterator to the beginning of the list

clear removes all elements from the list

empty true if the list has no elements

endreturns an iterator just past the last element of a list

erase removes elements from a list

insert inserts elements into the list

pop_back removes the last element of a list

pop_front removes the first element of the list

push_back add an element to the end of the list

push_front add an element to the front of the list

remove removes elements from a list

remove_if removes elements conditionally

sort sorts a list into ascending order

splice merge two lists in constant time

swap swap the contents of this list with another


#include <list>#include <iostream>using namespace std;void main() { //creer une liste (fifo) list<int> listInt; //rajouter des valeurs a la fin de la liste listInt.push_back(33); listInt.push_back(10); //afficher et enlever des valeurs au debut de la liste cout <<listInt.front() <<endl; listInt.pop_front(); //rajouter des valeurs a la fin de la liste listInt.push_back(44); //afficher et enlever des valeurs au debut de la liste cout <<listInt.front() <<endl; listInt.pop_front(); cout <<listInt.front() <<endl; listInt.pop_front();}

Utilisation du conteneur séquentiel listUtilisation du conteneur séquentiel list

331044


#include <vector>#include <iostream>using namespace std;

void main() { int MAX=10; //créer un vecteur qui stocke MAX entiers vector<int> vecInt(MAX); //remplir vecteur for (int i=0; i<MAX; i++) { vecInt[i] = i+1; } //afficher vecteur for (int i=MAX-1; i>=0; i--) { cout <<vecInt[i] <<endl; }}

10987654321

Utilisation du conteneur séquentiel vectorUtilisation du conteneur séquentiel vector


void main() { MyMap ListeMap; // Liste MyMap :: iterator my_it; // iterateur

char buffer[5];

ListeMap["Mary"] = 1234567; // Mary est un string ListeMap["Mary"] = 5551212; // Le numéro de Mary a changé

// Inserser en utilisant la fonction <tt>insert</tt>: TRi croissant ListeMap.insert( MyMap :: value_type( "Xavier", 777 ) ); ListeMap.insert( MyMap :: value_type( "Chuck", 1234567 ) ); ListeMap.insert( MyMap :: value_type( "James Bond", 007 ) ); ListeMap.insert( MyMap :: value_type( "Rob", 666 ) );

ListeMap.insert( MyMap :: value_type( "Xavier", 777 ) ); ListeMap.insert( MyMap :: value_type( "Chuck", 1234567 ) );

// Parcourir et afficher la liste for( my_it = ListeMap.begin(); my_it != ListeMap.end(); my_it++ ) cout << (*my_it).first << " " << (*my_it).second << endl;

// Effacer la liste de la mémoire ListeMap.erase(ListeMap.begin(), ListeMap.end());

cout << "\n FIN \n";}

#pragma warning(disable: 4786)

#include <iostream>#include <string>

#include <map> // Pour STL type map

using namespace std;typedef map < string, int > MyMap;

Chuck 1234567James Bond 7Mary 5551212Rob 666Xavier 777

FIN


#include <string>#include <iostream>

#include <map>using namespace std;void main(){

map<string, int, less<string > > age; // age est une map de string à int

age["Fred"] = 42; // Fred a 42 ans deage["Barney"] = 37; // Barney a 37 ans

++age["Fred"]; // incrémente l'âge de Fred.cout << "Fred a " << age["Fred"] << " an(s)\n";

--age["Barney"];cout << "Barney a " << age["Barney"] << " an(s)\n";

}

Documents

Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons