1 / 47

Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons

Programmation en. Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons Mohammed . Benjelloun @fpms.ac.be 2005-2006. Appel par valeurs, pointeurs, référence s ??!!. #include … void fonct (int a) { a=1 ; } void main(void){ int var = 5; fonct ( var ) ;

abril
Download Presentation

Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Programmation en Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons Mohammed.Benjelloun@fpms.ac.be 2005-2006

  2. Appel par valeurs, pointeurs, références ??!! #include … void fonct (int a) { a=1 ; } void main(void){ int var = 5; fonct (var); cout << var ; } #include … intfonct (int a) { a=1 ; return a; } void main(void){ int var = 5; var = fonct (var); cout << var; } #include … void fonct (int *a) { *a=1 ; } void main(void){ int var = 5; fonct (&var); cout << var ; } #include … void fonct (int &a) { a=1 ; } void main(void){ int var = 5; fonct (var); cout << var ; } 1 1 1 5

  3. Déclaration d'une structure comportant  des fonctions membres  struct point { int x ; int y ; } ; Supposons que nous souhaitions associer à la structure trois fonctions : • 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 : 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. struct point { int x , y; void initialise (int, int) ; void deplace (int, int) ; void affiche () ; } ; Définition des fonctions membres // 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" ; } point::initialise opérateur de "résolution de portée" Il signifie que l'identificateur initialiseconcerné 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.

  5. void point::initialise (int abs, int ord) { x = abs ; y = ord ; } void point::affiche () { cout << "Je suis en " << x << " " << y << "\n" ; } 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 struct point { int x, y ; void initialise (int, int) ; void deplace (int, int) ; void affiche () ; } ;

  6. 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".

  7. Définition d'une classe La déclaration d'une classe est voisine de celle d'une structure. Il suffit de: • remplacer le mot clé structpar 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. (masquage des données) • 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 • struct Client • { • // Données membres • string Nom, Prenom; • int Solde; • // Déclaration fonctions membres • void Saisir (); • void Afficher (); • bool Etat_Client(); • }; Accessibles depuis l'extérieur de la classe Encapsulation

  8. Que signifient public, private et protected ? Un membre déclaré public dans une classe peut être accédé par toutes les autres classes et fonctions. Un membre déclaré private dans une classe ne peut être accédé que par les autres membres de cette même classe. 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. 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 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 . void point::initialise (int abs, int ord) { x = abs ; y = ord ; }

  10. Un objet Un objet est donc une instanciation d’une classe. Cet objet possède tous les attributs et toutes les fonctions membres de la classe, mais avec des 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 ; …

  11. 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. 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 pointclass point { int x ; { public : int y ; int x ; void initialise (...) ; int y ; ..... void initialise (...) ; } ; .. .. } ;

  13. 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. #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(); } #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; }

  15. OK friend Direction; 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 };

  16. friend #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' } }; Classe amie 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

  17. Constructeur et destructeur 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. 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 } ; 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 !

  18. 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 ! point ::point () { cout << "In constructeur \n" ; x=0; y = 0; } 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 destructeur \n" ; x=0; y = 0; }

  19. Constructeurs par défaut 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]; } }; Point::Point() { X = 0; Y = 0; }

  20. CLAS :: CLAS () { cout << "Creation Objet \n" ; } CLAS :: ~CLAS () { cout << "Destruction Objet \n" ; } 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.

  21. Constructeurs par paramètres class CRec { public: int Long; int Larg; CRec( int Lo, int La){ Long = Lo; Larg = La; } }; Tab:: Tab ( int taille ) // Constructeur { TabElement = new TElement [taille] ; } Tab ::~ Tab () // Destructeur { delete [] TabElement ; }

  22. Ex2 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 } ; Ex1 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) ;

  23. 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. #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); } }; Initialisation et affectation 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 In Constructeur 0 Surface rectangle 1 = 200 Surface rectangle 2 = 687194768 Surface rectangle 3 = 720

  25. private: Erreur error C2248: 'Long' : cannot access private member declared in class 'CRec' 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(); }

  26. constructeur I (0, 1 ou 2 arguments) CRec X; // OK CRec Y(1); // OK CRec Z(1,2); // OK Constructeurs 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. class CRec { int Long; int Larg; public: CRec( int Lo=0, int La=0){ Long = Lo; Larg = La; } };

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

  28.     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    }

  29. #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 classe Paire : 3 5 Paire : d y Paire : 3.5 2.3 Paire : Salut A vous T prend la valeur int pour la classe point

  30. La réutilisation L’héritage L'héritage est un principe propre à la programmation orientée objet, permettant de créer une nouvelle classe à partir d'une classe existante. 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. Un omnivore est un animal mais pas forcement l’inverse 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" .

  31. Principe 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(); };

  32. En C++, il existe l’héritage simple, et l’héritage multiple. Dans ce 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 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. Mode de dérivation class ClasseDerivee : ModeClasseBase{...} 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.

  34. Héritage Public: Les types d’attributs C'est la forme la plus courante d'héritage class CptBanque { int ident; float solde; public: CptBanque(int id, float so = 0); void deposer(float); void retirer(float); float getSolde(); }; 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

  35. Héritage Public: Les types d’attributs C'est la forme la plus courante d'hé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 Les attributs private, protected et public de la classe de base restent les mêmes pour la classe dérivée. protégés (protected), c'est à dire accessibles aux membres de la classe et ses classes dérivées (par héritage); Le type d’attribut protected est le plus utilisé lors de l’héritage.

  36. 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 ("::"). 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(); } #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(); }; In F2 X In F1 X In F2 Y In F2 X In F3 K =5 In F3 K =14

  37. #include <iostream> 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" ; } /* --- 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 () ; } couleur = 5 Je suis en 10 20 Je suis en 12 24 Les membres publics de la classe de base (point) seront des membres publics de la classe dérivée (pointcol).

  38. 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> 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" ; } 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 () ; } Je suis en 5 10 Je suis en 20 30 Je suis en 20 30 Je suis en 20 30

  39. Utilisation de pointcol #include <iostream> #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 () ; } 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. class Prof : public Personne{ string Service; float Salaire; public : void saisie(); void afficher(); Prof *suiv; }; 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 Direction : public Prof{ string Titre; public : void saisieDir(); void afficherDir(); void moyenne(Etudiant *Tete); }; class Personne { string nom, prenom; public : void saisie(); void afficher(); string Lenom(); string Leprenom(); };

  41. 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. 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. C++ Lists :

  44. Utilisation du conteneur séquentiel list #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(); } 33 10 44

  45. Utilisation du conteneur séquentiel vector #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; } } 10 9 8 7 6 5 4 3 2 1

  46. #pragma warning(disable: 4786) #include <iostream> #include <string> #include <map> // Pour STL type map using namespace std; typedef map < string, int > MyMap; 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"; } Chuck 1234567 James Bond 7 Mary 5551212 Rob 666 Xavier 777 FIN

  47. #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 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"; }

More Related