++ - 1 M. BENJELLOUN : 2005-06 Info II Mohammed BENJELLOUN Service dInformatique Faculté Polytechnique de Mons 2005-2006.

Présentation au sujet: "++ - 1 M. BENJELLOUN : 2005-06 Info II Mohammed BENJELLOUN Service dInformatique Faculté Polytechnique de Mons 2005-2006."— Transcription de la présentation:

1 ++ - 1 M. BENJELLOUN : 2005-06 Info II Mohammed BENJELLOUN Service dInformatique Faculté Polytechnique de Mons Mohammed.Benjelloun@fpms.ac.be 2005-2006 Programmation en

2 ++ - 2 M. BENJELLOUN : 2005-06 Info II #include … void fonct (int a) { a=1 ; } voidmain(void){ int var = 5; fonct (var); cout << var ; } 5 #include … int fonct (int a) { a=1 ; return a; } voidmain(void){ int var = 5; var = fonct (var); cout << var; } 1 #include … void fonct (int &a) { a=1 ; } voidmain(void){ int var = 5; fonct (var); cout << var ; } 1 #include … void fonct (int *a) { *a=1 ; } voidmain(void){ int var = 5; fonct (&var); cout << var ; } 1 Appel par valeurs, pointeurs, références ??!!

3 ++ - 3 M. BENJELLOUN : 2005-06 Info II 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 () ; } ;

4 ++ - 4 M. BENJELLOUN : 2005-06 Info II // Définition des fonctions membres du type point #include 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 () ; } ;

5 ++ - 5 M. BENJELLOUN : 2005-06 Info II 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::initialise (int abs, int ord) { x = abs ; y = ord ; } 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 () ; } ;

6 ++ - 6 M. BENJELLOUN : 2005-06 Info II Objet et classe Le fondement de la programmation orientée objet (POO) est de pouvoir protéger certaines données dune structure, doù la nécessité des classe s. 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".

7 ++ - 7 M. BENJELLOUN : 2005-06 Info II 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 membres void Saisir (); void Afficher (); bool Etat_Client(); }; Cachées aux fonctions externes Accessibles depuis l'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)

8 ++ - 8 M. BENJELLOUN : 2005-06 Info II Que signifient public, private et protected ? public Un membre déclaré public dans une classe peut être accédé par toutes les autres classes et fonctions. private Un membre déclaré private dans une classe ne peut être accédé que par les autres membres de cette même classe. protected Un membre déclaré 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.

9 ++ - 9 M. BENJELLOUN : 2005-06 Info II 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 () ; } ; void point::initialise (int abs, int ord) { x = abs ; y = ord ; }

10 ++ - 10 M. BENJELLOUN : 2005-06 Info II Un objet Un objet est donc une instanciation dune classe. Un objet est donc une instanciation dune classe. Cet objet possède tous les attributs et toutes les fonctions membres de la classe, mais avec des valeurs dattributs propres à lobjet. Cet objet possède tous les attributs et toutes les fonctions membres de la classe, mais avec des valeurs dattributs propres à lobjet. 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 ; …

11 ++ - 11 M. BENJELLOUN : 2005-06 Info II 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

12 ++ - 12 M. BENJELLOUN : 2005-06 Info II 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 (...) ; } ;.... } ;

13 ++ - 13 M. BENJELLOUN : 2005-06 Info II class point { int x ; int y ; public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ; } ; void point::initialise (int abs, int ord) { x = abs ; y = ord ; } 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.

14 ++ - 14 M. BENJELLOUN : 2005-06 Info II #include 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 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(); }

15 ++ - 15 M. BENJELLOUN : 2005-06 Info II 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

16 ++ - 16 M. BENJELLOUN : 2005-06 Info II #include 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 friend Classe amie

17 ++ - 17 M. BENJELLOUN : 2005-06 Info II Un constructeur est une fonction membre dinitialisation (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 dinitialisation des différents champs de la variable. Constructeur et destructeur Il peut y avoir autant de constructeurs que lon veut (tant quils diffèrent par leur nombre et types darguments), ce qui est très intéressant pour initialiser les variables avec différents types; mais il ny a quun 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 } ;

18 ++ - 18 M. BENJELLOUN : 2005-06 Info II 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 ny a quun 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; }

19 ++ - 19 M. BENJELLOUN : 2005-06 Info II Constructeurs par défaut 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 nest 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]; } };

20 ++ - 20 M. BENJELLOUN : 2005-06 Info II 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 Salut Destruction Objet. CLAS :: CLAS () { cout << "Creation Objet \n" ; } CLAS :: ~ CLAS () { cout << "Destruction Objet \n" ; }

21 ++ - 21 M. BENJELLOUN : 2005-06 Info II Constructeurs 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; } };

22 ++ - 22 M. BENJELLOUN : 2005-06 Info II 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

23 ++ - 23 M. BENJELLOUN : 2005-06 Info II 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.

24 ++ - 24 M. BENJELLOUN : 2005-06 Info II #include 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 Param In Constructeur 0 Surface rectangle 1 = 200 Surface rectangle 2 = 687194768 Surface rectangle 3 = 720 Initialisation et affectation

25 ++ - 25 M. BENJELLOUN : 2005-06 Info II #include 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 error C2248: 'Long' : cannot access private member declared in class 'CRec'

26 ++ - 26 M. BENJELLOUN : 2005-06 Info II Constructeurs par défaut et par paramè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 défaut. Constructeur possédant des paramètres avec des valeurs de défaut. class CRec { int Long; int Larg; public: CRec( int Lo=0, int La=0){ Long = Lo; Larg = La; } }; CRec X; // OK CRec Y(1); // OK CRec Z(1,2); // OK constructeur I (0, 1 ou 2 arguments)

27 ++ - 27 M. BENJELLOUN : 2005-06 Info II #include using namespace std ; // création d'un patron de fonctions template 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 fonctions min (n, p) = 4 min (x, y) = 2.5 min (a, b) = A

28 ++ - 28 M. BENJELLOUN : 2005-06 Info II template 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 }

29 ++ - 29 M. BENJELLOUN : 2005-06 Info II #include using namespace std ; // création d'un patron de classe template class point { T x ; T y ; public : point (T abs=0, T ord=0) { x = abs ; y = ord ; } void affiche () ; } ; template void point ::affiche () { cout << "Paire : " << x << " " << y << "\n" ; } void main () { point ai (3, 5) ; ai.affiche () ; point ac ('d', 'y') ; ac.affiche () ; point ad (3.5, 2.3) ; ad.affiche () ; point as ("Salut", " A vous") ; as.affiche () ; } patron de classe T prend la valeur int pour la classe point Paire : 3 5 Paire : d y Paire : 3.5 2.3 Paire : Salut A vous

30 ++ - 30 M. BENJELLOUN : 2005-06 Info II La réutilisation L'héritage est un principe propre à la programmation orientée objet, permettant de créer une nouvelle classe à partir d'une classe existante. Lhé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 linverse Permet lextension 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.

31 ++ - 31 M. BENJELLOUN : 2005-06 Info II Principe de lhé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 lhé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(); };

32 ++ - 32 M. BENJELLOUN : 2005-06 Info II En C++, il existe lhéritage simple, et lhéritage multiple. Dans ce cours, nous ne nous intéresserons quà lhéritage simple. Dans la définition de la classe dérivée, afin dutiliser lhéritage, on ajoute le symbole : après le nom de la classe en précisant par la suite quelle est la classe de base. Ex: class ClasseDerivee : public ClasseBase {...} 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 {... };..

33 ++ - 33 M. BENJELLOUN : 2005-06 Info II Mode 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 dhé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 ClasseDerivee : Mode ClasseBase {...}

34 ++ - 34 M. BENJELLOUN : 2005-06 Info II class CptBanque { int ident; float solde; public: CptBanque(int id, float so = 0); void deposer(float); void retirer(float); float getSolde(); }; public class CptPlus : 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 Public: Les types dattributs C'est la forme la plus courante d'héritage

35 ++ - 35 M. BENJELLOUN : 2005-06 Info II Héritage Public: Les types dattributs C'est la forme la plus courante d'héritage Classe de baseClasse dérivée private private protected protected public public Les attributs private, protected et public de la classe de base restent les mêmes pour la classe dérivée. Le type dattribut protected est le plus utilisé lors de lhéritage. class ClasseDerivee : public ClasseBase 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);

36 ++ - 36 M. BENJELLOUN : 2005-06 Info II REDEFINITION DE METHODES DANS LA CLASSE DERIVEE Les méthodes (fonctions, …) de la classe de base peuvent être redéfinies dans la classe dérivée (le même nom que dans la classe de base). Elles demeurent accessibles via l'opérateur de résolution de portée ("::"). #include 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

37 ++ - 37 M. BENJELLOUN : 2005-06 Info II /* --- 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 () ; } #include using namespace std ; // ------------ 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 = 5 Je suis en 10 20 Je suis en 12 24

38 ++ - 38 M. BENJELLOUN : 2005-06 Info II 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 () ; } #include using namespace std ; 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 10 Je 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;

39 ++ - 39 M. BENJELLOUN : 2005-06 Info II #include point.h #include " point.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 : 5 Je suis en 10 20 Je suis en 12 24 et ma couleur est : 5 Je suis en 12 24 et ma couleur est : 2

40 ++ - 40 M. BENJELLOUN : 2005-06 Info II 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); };

41 ++ - 41 M. BENJELLOUN : 2005-06 Info II 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; …

42 ++ - 42 M. BENJELLOUN : 2005-06 Info II 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++ Algorithms C++ Vectors C++ Double-Ended Queues C++ Lists C++ Priority Queues C++ Queues C++ Stacks C++ Sets C++ Multisets C++ Maps C++ Multimaps C++ Bitsets Iterators STL

43 ++ - 43 M. BENJELLOUN : 2005-06 Info II C++ Lists : Container constructorscreate lists and initialize them with some data Container operatorsassign and compare lists assignassign elements to a list beginreturns an iterator to the beginning of the list clearremoves all elements from the list emptytrue if the list has no elements end returns an iterator just past the last element of a list eraseremoves elements from a list insertinserts elements into the list pop_backremoves the last element of a list pop_frontremoves the first element of the list push_backadd an element to the end of the list push_frontadd an element to the front of the list removeremoves elements from a list remove_ifremoves elements conditionally sortsorts a list into ascending order splicemerge two lists in constant time swapswap the contents of this list with another

44 ++ - 44 M. BENJELLOUN : 2005-06 Info II #include using namespace std; void main() { //creer une liste (fifo) list 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 list 33 10 44

45 ++ - 45 M. BENJELLOUN : 2005-06 Info II #include using namespace std; void main() { int MAX=10; //créer un vecteur qui stocke MAX entiers vector 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; } 10 9 8 7 6 5 4 3 2 1 Utilisation du conteneur séquentiel vector

46 ++ - 46 M. BENJELLOUN : 2005-06 Info II 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 insert : 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 #include // Pour STL type map using namespace std; typedef map MyMap; Chuck 1234567 James Bond 7 Mary 5551212 Rob 666 Xavier 777 FIN

47 ++ - 47 M. BENJELLOUN : 2005-06 Info II #include using namespace std; void main(){ map > age; // age est une map de string à int age["Fred"] = 42; // Fred a 42 ans de age["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"; }