Héritage et composition diagramme de classes… approche orienté objet… traduction au niveau du codage ? mécanismes de programmation de ces concepts concepts non algorithmiques mais objets !

Héritage et composition les relations entre objets : une voiture moteur une voiture véhicule une voiture conducteurs a un composition est un héritage a des (pas dans le sens 'possède') association

Héritage et composition à chaque relation son implémentation composition : la classe A comporte un objet de classe B si objet de classe B partagé par plusieurs objets de classe A : pointeur vers objet de classe B membre static

Composition tout comme une struct peut contenir une struct class moteur {// ici on trouve du code bien écrit}; class voiture { private : char *marque; moteur m; }; tout comme une struct peut contenir une struct ou moteur *m; ou static moteur m;

Liste d'initialisation pour le constructeur de la classe contenante : class voiture { private : char *marque; moteur m; public : voiture(moteur mm, char*ma) m=mm; // intialisation de la marque } }; ce code d'initialisation n'est pas du code 'efficace' voiture(moteur mm, char *ma):m(mm) // code autre que des affectations systématiques

Liste d'initialisation valable pour les types de base (int et consorts) class foo{// que du bon code}; class bar { private : foo f; int i; char c; public : bar(foo pff, int pii, char pcc):f(pff),i(pii),c(pcc) {} ~bar() {} // autres fonctions membres };

Héritage syntaxe la classe ainsi définie hérite des classes listées class classe : dérivation classe[, dérivation classe,…] { // code de la classe }; la classe ainsi définie hérite des classes listées

Héritage dérivation : indique l'accessibilité entre classes principe : une classe B héritant de A contient tous les membres de A un objet de classe B contient un sous-objet de classe A exemple avec Dev

Héritage privé dérivation : public, private, protected héritage private (par défaut) : public private protected inacessibles private dans la classe de base dans la classe dérivée

Héritage privé rôle de l'héritage privé class A : private B { // code de A }; A est une sorte de B, mais les utilisateurs n'ont pas à le savoir. A offre une interface qui lui est propre. exemple avec Dev

Héritage protégé héritage protected : public protected protected inacessibles private dans la classe de base dans la classe dérivée membres protected accessibles aux classes dérivées

Héritage public héritage public : type de dérivation très utilisé protected protected private private dans la classe de base dans la classe dérivée type de dérivation très utilisé

Redéfinition de fonction class D : public B {}; D est-un B "en mieux" les fonctions de B : D doit les proposer c'est le cas ! D d; d.f(); // ok si f() est définie dans B !

Redéfinition de fonction D peut implémenter f(); mais D::f() masque B::f() pas appel aux deux ! appel explicite possible exemple avec Dev

Troncature d'objet si D est un B alors… exemple avec Dev D d; B b; b=d; //? B *ptr; ptr=&d; // ??? ptr->f(); //??? effets exemple avec Dev

Polymorphisme déclaration d'un tableau de B contenant donc des objets de classe B, des objets de classe D… définition ? B tablo[100]; ou B *tablo; tablo = new B[42];

Polymorphisme problèmes : la troncature ! donc tableau de pointeurs : D d; tablo[2]= d; // ok mais troncature donc tableau de pointeurs : B* tablo[100]; B[0] = new B; B[1] = new D; utilise les types statiques des objets ! exemple avec Dev

Polymorphisme possibilité de déterminer le type dynamique de l'objet : forcer le compilateur à le traiter. mot clef virtual dans la définition de la fonction au niveau de la classe de base.

Fonctions virtual contraintes sur les fonctions virtuelles redéfinies (appelons la f() ): f() retourne T* f() retourne T& f() retourne T rédéfinion de f() : (une sorte de T)* rédéfinion de f() : (une sorte de T)& rédéfinion de f() : T

Classe abstraite abstraction / taxonomie / concept super classe pas instanciable rôle d'interface, de modèle obligation de dériver des classes

Classe abstraite * 1 instrument de musique orchestre instrument à corde instrument à vent cuivres bois piano violon contrebasse tuba trompette hautbois

Classe abstraite interface de instrument ? jouer(); class instrument { public : virtual void jouer(note)=0; } fonction virtuelle pure : ne peut être appelée doit être redéfinie par les classes dérivées exemple avec Dev

Classe abstraite quid des classes abstraites intermédiaires ? ne doivent pas redéfinir les fonctions virtuelles car classes abstraites peuvent ajouter des informations d'interface non instantiables !

Retour sur virtual exemple de redéfinition class figure { public: virtual void dessiner()=0; virtual figure *symetrique(droite)=0; }; class triangle public : void dessiner(){//le code//} figure *symetrique(droite d){//du code}