Programmation orientée objet (C++)

Autre cours
Devoir sur table le 11 mars 2022 (héritage compris) -> il peut que améliorer la note (même fonctionnement que le premier semestre, exemple de travail :
- est-ce que le code compile ?
- qu’affiche le constructeur/destructeur, etc…
- implanter des fonctions d’une classe
- la syntaxe ne contras pas trop
- la cohérence des classes, etc. est importante

Examen : Vendredi 22 avril 2022 : 16h30-18h.

• Tout est suscpetible d’apparaître (héritage, …)

Séance de rattrapage le 11 avril 2022

Choisir son projet le plus tôt possible
Projet à rendre avant la soutenance.
Séance d’oral entre le 16 et le 22 mai.

• Classe

  Passer de C à C++

  C	C++
  #include <stdio.h>	#include <cstdio>
  gcc source.c	g++ source.cpp -std=c++11
  typedef struct maStruct { ... } MaStruct;	struct MaStruct { ... };

  Les ajouts du C++ par rapport au C

  • Mécanisme de POO (Programmation Orientée Objet)
    • Encapsulation
      • il y a des champs et des fonctions publique ou privé
    • Polymorphisme
    • Template (patron de classe ou de fonction)
    • Référence
    • Exceptions
    • Espace de noms
    • Héritage

  flowchart TD
   1[Voiture]-->2[Camion]
   1-->3[Vélo]
   1-->4[Voiture]
  

  Exemple de modélisation d’une fraction en C++

  #include<cstdio>
  
  int calcPGCD(int a, int b) {
      if(b == 0) return a;
      return pgcd(b, a % b);
  }
  
  struct Fraction {
      int num; // numérateur
      int den; // dénominateur
      int pgcd;
  
      void afficher(void) { /* c'est une méthode, pas une fonction, elle est
                             * liée à un objet */
          printf("%d/%D\n", num, den);     
      }
  
      Fraction produit(Fraction b) {
          Fraction res;
          res.num = num * b.num;
          res.den = den * b.den;
  
          return res;
      }
  
      void agrandir(int a) {
          num *= a;
          den *= a;
      }
  
      void calculePGCD(void) {
          pgcd = calcPGCD(num, den);
      }
  
      void simplifierFraction(void) {
          calculePGCD(); // Wow! on utilise une méthode de l'objet
          num = num / pgcd;
          den = den / pgcd;
      }
  
  };
  
  int main() {
      // Définition d'une fraction
      Fraction a;
      a.num = 6;
      a.den = 2;
      a.afficher();
  
      // Utilisation d'une méthode de l'objet
      Fraction c = a.produit(b);
      c.afficher();
  
      // On peut donner modifier la valeur de l'objet
      c.agrandir(2);
      c.afficher();
  
      // Encore une exemple
      c.calculePGCD();
      printf("PGCD: %d\n", c.pgcd);
  
      // Encore un exemple
      a.afficher();
      a.simplifierFraction();
      a.afficher();
  }
  

  On ajoute un constructeur à notre programme

  #include<cstdio>
  
  int calcPGCD(int a, int b) {
      if(b == 0) return a;
      return pgcd(b, a % b);
  }
  
  struct Fraction {
      private : // attributs/membre privés, pas accessible à l'extérieur de la classe
      int num; // numérateur
      int den; // dénominateur
  
      // Constructeur du programme quand aucun argument renseigné
      Fraction(void) { }
      
      public : // attribut/membre publics, accessible à l'extérieur de la classe
      int pgcd;
  
      // Constructeur du programme quand 2 arguments renseignés
      Fraction(int nump, int denp) {
          printf("Appelle d'un constructeur\n");
          num = nump;
          den = denp;
          pgcd = calcPGCD(nump, denp);
      }
  
      void afficher(void) { /* c'est une méthode, pas une fonction, elle est
                             * liée à un objet */
          printf("%d/%D\n", num, den);     
      }
  
      Fraction produit(Fraction b) {
          Fraction res;
          res.num = num * b.num;
          res.den = den * b.den;
  
          return res;
      }
  
      // Accesseur num
      void setNum(int pnum) {
          num = pnum;
          pgcd = calculePGCD();
      }
  
      // Accesseur den
      void setDen(int pden) {
          den = pden;
          pgcd = calculePGCD();
      }
  
      void agrandir(int a) {
          num *= a;
          den *= a;
      }
  
      void calculePGCD(void) {
          pgcd = calcPGCD(num, den);
      }
  
      void simplifierFraction(void) {
          calculePGCD(); // Wow! on utilise une méthode de l'objet
          num = num / pgcd;
          den = den / pgcd;
      }
  };
  
  int main() {
      // Définition d'une fraction
      Fraction a(6, 2);
      printf("PGCD: %d\n", a.pgcd);
  
      // Modification du dénominateur
      a.setDen(3);
      printf("PGCD: %d\n", a.pgcd); // incroyable, le PGCD reste vrai !
      
      a.afficher();
      a.simplifierFraction();
      a.afficher();
  }
  

  struct ou class sont équivalent, la seule différence est que l’intérieur d’une struct est publique par défaut à l’instar du contenu d’une class qui est privée par défaut

  // Différence entre struct et class
  struct MaClasse {
      // public: implicite
  };
  
  class MaClasse {
      // private: implicite
  };
  

  On peut définir une méthode d’une struct en dehors de la struct. C’est mieux de définir directement à l’intérieur que à l’extérieur quand même

  struct MaClasse {
      int maMethode();
  };
  
  int MaClasse::maMethode() {
      return 3;
  }
  

  Il est préférable de définir une class à l’extérieur du fichier .cpp, dans un fichier .hpp.

  Fichier xd.hpp

  #ifndef xd
  #define xd
  
  struct MaClasse {
      int maMethode(void);
  };
  
  int MaClasse::maMethode(void) {
      return 3;
  }
  
  #endif
  

  Fichier main.cpp

  #include <iostream>
  #include "xd.hpp"
  
  using namespace std;
  
  int main(void) {
      MaClasse a;
      cout << a.maMethode() << endl;
  }
  

• Constructeur et destructeur

  On peut définir un constructeur de classe qui sera appellée lorsque l’on instancie un nouvel objet.

  struct MaClasse {
      MaClasse(void) {
          cout << "coucou" << endl;
      }
  };
  

  Pour éviter d’appeller le constructeur, il faut utiliser malloc (faut pas faire ça, c’est pas cohérent).
  Il ne faut donc pas utiliser malloc pour utiliser l’objet avec des *, il faut utiliser new (et delete remplace free).

  int main(void) {
      /* On réserve de la place, comme malloc, mais
       * là on appelle bien le constructeur */
      MaClasse* b = new MaClasse();
  
      // ...
  
      delete b;
  
      return 1;
  }
  

  On utilises delete car on peut aussi définir un destructeur (comportement lorsqu’on libère la classe), et free ne le permet pas.

  Il y a donc plusieurs méthodes qui sont crées implicitement : constructeur, destructeur.

  #include <iostream>
  
  using namespace std;
  
  struct Tableau {
      private:
          int taille;
          int* tab;
  
      public:    
          // Constructeur
          Tableau(int ptaille) {
              tab = new int[ptaille];
              taille = ptaille;
  
              for(int i = 0; i < taille; i++)
                  tab[i] = 0;
          }
  
          void afficher(void) {        
              for(int i = 0; i < taille; i++)
                  cout << ' ' << tab[i];
              cout << endl;
          }
  
          // Destructeur        
          ~Tableau(void) {
              delete[] tab;
          }
  };
  
  int main(void) {
      Tableau tab1(10);
      tab1.afficher();
  }
  

  Résumé

  Le(s) constructeur(s) possède(nt) le même nom que la classe. Pour le destructeur on ajoute un ~ devant.
  Exemple :

  class MaClasse {
      MaClasse(...) {
          // corps du constructeur
      }
  
      ~MaClasse(...) {
          // corps du destructeur
      }
  };
  

  Il ne peut y avoir qu’un seul destructeur. Le destructeur ne prend jamais de paramètre. Par défaut pour toute classe un constructeur et un destructeur implicite sont générés.
  Le mot clé this est une expression qui donne l’adresse de l’objet de la classe.

  Les opérateurs new et delete (ainsi que new[] et delete[]) sont à utiliser sur les classes car ils appellent les constructeurs et destructeurs.
  Exemple :

  MaClasse* a = new MaClasse(...);
  MaClasse* tab = new MaClasse[13];
  
  delete a;
  delete[] tab;
  

  Cf. Chapitre 4 pour d’autre façon d’appeller des constructeurs (il y aussi le constructeur de recopie).

• Référence et surcharge de fonction

  Exemple

  void f(int param) {
      param = 2;
  }
  
  void g(int& param) {
      param = 2;
  }
  
  int& h(int& param) {
      return param;
  }
  
  int main(void) {
      int  a = 2;
      int& b = a;
      b = 3;
  
      // ici b et a ont pour valeur 3
      b=3;
      
      // ici b et a ont pour valeur 1
      a=1;
  
      f(a);
      // a est resté sur 1
  
      f(b);
      // ici a et b valent toujours 1
  
      g(a);
      // ici a vaut 2
  
      // on ne peut pas définir une référence non initialisée
      // int& c;     --> ne fonctionnera pas
      // int& c = 3; --> erreur aussi car 3 n'est pas une variable
  
      /* Représentation d'une variable
       * peut donc être modifiée */
      h(a) = 4;
      // ici a (et b) vale(nt) 4
  
      return 0;
  }
  

  Manière de voir une référence

  int main(void) {
      int  b = 4;
      int& r = b; // int* r = &b; à l'initalisation seulement
  
      r = expr; // *r = expr;
  
      return 0;
  }
  

  Récapitulatif catégorie (lvalue et rvalue) et type

  lvalue -> left-value
  rvalue -> right-value

  int main(void) {
      int a, b;
  
      // ici on assigne la valeur contenu dans b dans la variable a
      a = b;
  
      // un peu comme
      a = 3; // --> possible
      // 3 = a  --> pas possible 
  
      return 0;
  }
  

  Toute expression possède un type (int, float, struct A { }, int*, A*) et une catégorie (lvalue et/ou rvalue).
  Les références doivent être réinitialiser avec une expression lvalue.

  Exemple de lvalue

  int main(void) {
      int T[10];
      T[1]; // équivalent à *(T+1) est une lvalue
      T[1] = 3;      // et donc on a le droit d'écrire
      int& a = T[1]; // Ok T[1] est lvalue
  
      return 0;
  }
  

  Surcharge de fonction

  En C on a pas le droit de définir deux fonctions du même nom, c’est possible en C++ lorsque ces deux fonctions ne prennent pas les mêmes arguments

  Exemple

  int fonction(int a) { ... } // fonction 1 (signature fonction(int _))
  void fonction(float a) { ... } // fonction 2 (signature fonction(float _))
  // void fonction(int c) { ... } /* erreur -> il existe déjà une */
                                  /* fonction(int _);
                                   * --> le type de retour n'influe donc
                                   * pas sur la surcharge */
  float fonction(int a, int b) { ... } // ok (signature fonction(int _, int _))
  
  int main(void) {
      fonction(3); // fonction 1 appellée car 3 est de type integer
  
      fonction(3.1f); // fonction 2 appellée car 3. est de type float
  
      return 0;
  }
  

  La signature d’une fonction est la liste de son identifiant suivie de la liste des types de paramètres.

  Règles de la signature unique

  Dans un même espace de nom, on peut définir plusieurs fonction ayant le même identifiant tant que leur signature sont toute différente deux à deux.

  Choix de la fonction

  void procedure(long int a) { ... }
  void procedure(float a) { ... }
  
  struct A { ... };
  void maFonction(A a) { ... } // fonction 1
  void maFonction(float c) { ... } // fonction 2
  void maFonction(float c, float b) { ... } // fonction 3
  
  int main(void) {
  
      procedure(3); /* on sait pas trop quelle fonction va être appellée
                     * - soit on convertis en long int, soit en float 
                     * -> donc erreur du compilateur à cause de l'ambiguïté */
  
      procedure((long int)3); /* Dans ce cas là, la procédure 1
                               * est correctement choisie car on
                               * force la conversion. */
  
      maFonction(3); /* ok fonction 2 choisie car
                      * aucune ambiguïté/conversion possible */
  
      maFonction(4, 5); // idem, fonction 3 choisie et tout est ok
  
      return 0;
  }
  

  Lors d’un appel de fonction surchargée

  • S’il existe une fonction dont les types des paramètres correspondent exactement aux arguments de la fonction alors cette fonction est forcément unique (règle de la signature unique) et elle est donc choisie par le compilateur.
  • Sinon le compilateur essaye de choisir une fonction en effectuant des conversions implicites des arguments.
    • Si le compilateur trouve plusieurs fonction candidates ou aucune, une erreur survient.

  Valeur par défaut de paramètre fonction

  void maFonction(int a, int b = 2, int c = 4) { ... }
  // void procedureTruc(int a = 2, int b) { ... } /* erreur car les */
                                                  /* paramètres par défaut
                                                   * doivent être à la fin */
  
  int main(void) {
      maFonction(3);       // ok | a = 3, b = 2 et c = 4
      maFonction(2, 4);    // ok | a = 2, b = 4 et c = 4
      maFonction(6, 7, 1); // ok | a = 6, b = 7 et c = 1
      // maFonction();     // erreur car a non renseignéint *p*
  
      return 0;
  }
  

• Références de déplacement et références constantes et recopie

  const int \neq int, ils ont le même type mais un objet différent.

  Il faut toujours initalisé les const.

  void f(const int a) { ... }
  void f(int a) { ... }
  
  int main(void) {
      int i;
      const int ci = 4;
  
      int *p;
      const int* p2;
  
      const int* const p3 = &i; 
      int *const p4 = &i; /* on peut pas faire = &ci car on pointerais vers
                           * une const */
          // p = &ci /* pareil on ne doit pas modifier
                 /* une const donc impossible de faire ça */
  
      return 0;
  }
  

  Utilisation dans des classes

  #include<iostream>
  
  using namespace std;
  
  class A {
      // private: // privé par défaut donc inutile
          const int a;
          const int b;
  
      public:
          A(int pa, int pb = 4) : a(pa), b(pb) { } /* l'ordre est important
                                                    * c'est a, puis b, car on
                                                    * demande pa, puis pb 
                                                    * (respect de l'ordre de 
                                                    * construction) */
  
          voidafficher(void) {
              cout << a << endl;
              cout << b << endl;
          }
  };
  
  int main(void) {
      A objet1(3, 6);
      objet1.afficher();
  
      A objet2(3);
      objet2.afficher();
  
      return 0;
  }
  

  Références constantes

  int main(void) {
      int a = 1;
      const int& r = a;
      // r = 3; // impossible, on ne peut pas modifier depuis une const
      a = 2; // possible
      const int& r = b; // possible
      // int& r2 = b; // impossible aussi pour la même raison que précedemment
  
      return 0;
  }
  

  Une rvalue peut être référencé à l’aide d’une référence constante.

  #include<iostream>
  
  using namespace std;
  
  class A {
          const int a;
          const int b;
  
      public:
          A(int pa, int pb = 4) : a(pa), b(pb) { }
  
          voidafficher(void) const { // mot clé const ici !!!
              cout << a << endl;
              cout << b << endl;
          }
  };
  
  A g(void) {
      // autre syntaxe pour appeller le constructeur
      return A { 2 };
  }
  
  int main(void) {
      int a;
      int& r = a;
      const A& r1 = g();
      r1.afficher();
  
      // encore une autre syntaxe de constructeur
      A objet = 4; /* == objet { 4 }; --> valable que quand
                    *                     il n'y a qu'un seul
                    *                     paramètre */
      
      return 0;
  }
  

  Explication de pourquoi on a le mot clé const à la suite de la fonction

  Explicit le fait que la fonction ne modifie rien à l’objet.
  -> Si on utilises const à mauvais escient, le compilateur refusera de compiler.
  -> Si on veut quand même modifier quelque chose dans la fonction const, il faut le faire sur un attribut mutable
  -> Mot clé static permet qu’une valeure soit gardé d’un objet à l’autre quand définie dans une classe.

  Exemple

  #include<iostream>
  
  using namespace std;
  
  class Paire {
      int a;
      int b;
      mutable int temp;
      static int nb; /* ici c'est une déclaration pour
                      * pouvoir le définir à l'exterieur */
  
      public:
          Paire(int pa, int pb) {
              a = pa;
              b = pb;
              nb++;
          }
  
          void afficher(void) const {
              temp = 1;
              cout << "p: " << a << ", s: " << b << endl;
          }
  
          static int compter() {
              return nb;
          }
  
          ~Paire() {
              nb--;
          }
  };
  
  int Paire::nb = 0; // ici c'est une définition (dans un seul fichier objet)
  
  int main(void) {
      cout << Paire::compter() << endl; // on l'appel en dehors de la classe
      Paire const a(4, 2);
      a.afficher();
  
      cout << Paire::compter() << endl;
  
      {
          Paire b(1, 1); 
          cout << Paire::compter() << endl; // on l'appel en dehors de la classe
  
          Paire c(1, 1);
          cout << Paire::compter() << endl; // on l'appel en dehors de la classe
      }
  
      cout << Paire::compter() << endl; // on l'appel en dehors de la classe
  
      return 0;
  }
  

  Une variable static doit être définie à l’extérieur car elle est unique, il faut donc la définir en dehors de la classe pour que “tout le monde” soit au courant que cette variable est reservée.

  Constructeur de recopie tab

  #include<iostream>
  
  using namespace std;
  
  class Tab {
      int* tab;
      // int taille; -> on se dit que tout les tableaux sont de taille 10
      
      public:
          Tab(void) {
              cout << "appel du constructeur" << endl;
              tab = new int[10];
              
              for(int i = 0; i < 10; i++)
                  tab[i] = 0;
          }
      
          Tab(Tab const &original) { // ici c'est le constructeur de recopie
              cout << "appel du constructeur de copie" << endl;
              tab = new int[10];
              for(int i = 0; i < 10; i++)
                  tab[i] = original.tab[i];
          }
  
          void set(int indice, int val) {
              tab[indice] = val;
          }
  
          void afficher(void) {
              for(int i = 0; i < 10; i++) {
                  cout << tab[i];
                  cout << " ";
              }
              cout << endl;
          }
      
          ~Tab() {
              cout << "appel du destructeur" << endl;
              delete[] tab;
          }
  };
  
  void f(Tab b) {
      b.set(3, 1);
      b.afficher();
  }
  
  int main(void) {
      Tab a;
  
      a.set(3, 5);
      a.afficher();
  
      f(a);
      a.afficher();
  
      return 0;
  }
  

  Le constructeur de recopie est appellée automatiquement lors d’un appel de fonction.

• Fonctions et classes amies, espace de nom

  Fonctions et classes amies

  Exemple de fonction ami

  #include<iostream>
  
  class A {
      int a;
      friend void f(void);
      friend int main(void);
  };
  
  void f(void) {
      A obj;
      obj.a = 1;
  }
  
  int main(void) {
      A obj;
      obj.a = 3;
      std::cout << obj.a << std::endl;
  
      return 0;
  }
  

  Une fonction amie peut modifier des attributs d’une classe. On peut aussi le faire pour les membres d’une classe

  Exemple

  #include<iostream>
  
  class A {
      int a = 1;
      friend void f(void);
      friend int main(void);
      friend class B; // classe B déclarée ami de la classe A
  };
  
  class B {
      A objA;
      
      public:
          void modif(void) {
              objA.a = 5;
          }
  
          void affiche(void) {
              std::cout << objA.a << std::endl;
          }
  };
  
  int main(void) {
      B objB;
      objB.affiche();
      objB.modif();
      objB.affiche();
  
      return 0;
  }
  

  Résumé amis

  On peut déclarer amie d’une classe A une fonction f externe de la classe A avec le mot clé friend. Ce qui permet à la fonction f d’acceder aux membres privés de la classe A. On peut rendre une classe B amie d’une classe A, ce qui a pour effet de rendre toute les méthode de la classe B comme des fonctions amie de la classe A.

  Exemple

  class A {
      friend void f(void); // f est l'amie de la classe A
      friend class B; // B est l'amie de la classe A
  };
  
  class B { ... };
  void f(void) { ... };
  

  Espace de nom

  Les identificateurs servent à nommer :

  • les variables/objets
  • les fonctions
  • les types

  Les identificateurs peuvent être créer à partir de :

  • définitions
  • déclarations

  Exemple de déclaration sans définition d’une fonction, fichier1.cpp :

  extern int varGlobal;
  
  void fonctionExterne(int, float);
  
  int main(void) {
      fonctionExterne(4, 2); /* Dans ce cas là, à la compilation,
                              * tout se  passe bien, mais ça plante
                              * à l'édition de liens. Pour que ça 
                              * fonctionne, il faudrais un fichier en
                              * plus qui définit fonctionExterne. */
      varGlobal = 3;
  
      return 0;
  }
  

  Exemple d’un autre fichier fichier2.cpp :

  int varGlobal = 4;
  
  void fonctionExterne(int a, void b) {
      a = 0;
      b = 1.;
  }
  

  On peut donc compiler sans problème maintenant
  g++ fichier1.cpp fichier2.cpp

  On utilises un pointeur d’une classe A vers une classe B :

  #include<iostream>
  
  class B; // on déclare la classe B pour qu'elle soit utiliser dans la classe A 
  
  class A {
      B* pb;
  };
  
  class B {
      A* pa;
  }
  int main(void) {
      
      return 0;
  }
  

  La visibilité d’un identificateur va de l’endroit où est créé (bloc/fonction/fichier) jusqu’à la fin du bloc/fonction/fichier.

  Un espace de nom est toujours définit hors de toute fonction. Il “couvre” les identificateurs créé à l’intérieur.

  Exemple

  namespace monEspace {
      int maVariable = 0;
  }
  
  int main() {
      // maVariable = 1; // -> Erreur
      monEspace::maVariable = 1; // Ok
  
      return 0;
  }
  

  Un même espace de nom peut être complété en plusieurs fois.

  Illustration

  namespace monEspace {
      int a;
      void f(void);
  }
  ...
  namespace monEspace {
      int b;
      ...
  }
  

  On peut définir des alias d’espace de nom.

  Exemple

  namespace monGrandEspaceDeNom {
      int i;
      ...
  }
  
  namespace mgedn = monGrandEspaceDeNom;
  
  mgedn::i = 3; // ok alias
  

  On peut importer dans le bloc/fonction/fichier courant tout les identificateurs d’un espace de nom avec using namespace MonEspace (utile avec std).

  On peut imbriquer les espaces de nom.

  Exemple

  int i;
  namespace A {
      int i = 1;
      namespace B {
          int i = 2;
      }
  }
  ... i;       // fait allusion au i qui vaut 0
  ... A::i;    // fait allusion au i qui vaut 1
  ... A::B::i; // fait allusion au i qui vaut 2
  

  Exemple un peu plus complet

  #include<string> // inclu std::string
  #include<iostream>
  #include<.....> // inclu monEDN::string
  
  using namespace std;
  
  class B {
      public:
          static int a;
  };
  
  namespace A {
      namespace B {
          int i = 0;
      }
      int i = 2;
  }
  
  int i = 1;
  
  int main(void) {
      using namespace A;
      cout << A::B::i << endl;
      A::B::i = 4;
      cout << A::B::i << endl;
      // cout << i << endl; // on ne sais pas a quelle "i" on fait allusion
  
      return 0;
  }
  

• Opérateurs

  Nom	C++	Sens
  Binaire	() [] ->	->
  Unaire	+ - ++ -- ~ * &	<-
  Unaire	new new[] delete delete[] (cast)	->
  Binaire	* / %	->
  Binaire	+ -	->
  Binaire	<< >>	->
  Binaire	== !=	->
  Binaire	&	->
  Binaire	^	->
  Binaire	｜｜	->
  Binaire	&&	->
  Binaire	｜	->
  Binaire	= += -= *= /= %= &= ^= ｜= <<= >>=	<-

  Décomposition de comment une expression est gérer par l’ordinateur

  ((a+((f\times b)\times c)) = (d = (++a)))

  flowchart TD
  1[=] --> 2 & 3
  2[+] --> 4 & 5
  3[=] --> 8 & 9
  4[a]
  5[*] --> 6 & 7[c]
  6[f]
  7[b]
  8[d]
  9[++] --> 10
  10[a]
  

  Test d’opérateurs testOp.cpp :

  #include<iostream>
  
  class Frac {
      int num;
      int den;
      public:
          Frac(int n, int d) {
              num = n;
              den = d;
          }
          
          void afficher(void) {
              std::cout << "num:" << num << ", den:" << den << std::endl;
          }
  
          Frac operator +(const Frac& a) const {
              Frac retour(0, 0);
              retour.num = a.num * den + num * a.den;
              retour.den = a.den * den;
  
              return retour;
          }
  
          friend Frac operator *(const Frac& a, const Frac& b);
  };
  
  Frac operator *(const Frac& a, const Frac& b) {
      Frac retour(a.num, a.den);
      retour.num *= b.num;
      retour.den *= b.den;
  
      return retour;
  }
  
  int main(void) {
      Frac const a(3, 2);
      Frac const b(1, 4);
      Frac c = a + b; // Frac = a.operator + (b);
      c.afficher();
  
      return 0;
  }
  

  Il faut penser à modifier l’opérateur d’affectation quand on créer une classe qui utilises de la mémoire (pour renvoyer une copie d’un élément…) et éviter de perdre un élément.
  Exemple depuis l’exemple précédent :

  Frac operator =(const Frac& b) {
      std::cout << "opérateur affectation" << std::endl;
      num = b.num;
      den = b.den;
  
      return *this;
  }
  

  Ainsi dans le main…

  c = a; // on garde a et on a un nouveau c
  

  void maFonction(Frac a) {
      a.afficher();
  }
  
  int main(void) {
      maFonction(3);
  }
  

  Dans ce cas, le compilateur ne rale pas, malgré que la fonction maFonction prenne un Frac et non un int, car il y a une conversion implicite de int vers Frac.

  Bilan

  Lorsqu’un classe (ex: class A { ... };)est définie, alors par défaut est construit :

  • un constructeur sans paramètre (ex: A() { })
  • un destructeur (forcément sans paramètre) (ex: ~A() { })
  • un constructeur de recopie (ex: A(A const & a) { ... })
  • un opérateur d’affectation (ex: A operator =(const &) { })

  Remarque

  • L’écriture explicite par le concepteur de la classe d’un de ces quatres méthodes l’efface (en gros ces constructeurs par défaut ne sont pas construit si le dev en a écrit).
  • On peut forcer le compilateur a ne pas construire l’une de ces quatres méthodes en écrivant : <methode(...)=delete;, exemple :

  class A {
      A(void) = delete; // constructeur
      ~A(void) = delete; // desctucteur
      void operator =(...) = delete; // affectation
      A(const A& a) = delete; // recopie
  };
  

  • On peut surcharger les opérateurs classiques de C++, exemple :

  class A { ... };
  A operator +(A a, A b)  {// fonction qui renvoie un A
      ...
  }
  int main() {
      A a;
      A b;
      ...
      ... a + b ... sera transformé en : ... operator +(a, b) ...
      ...
      return ...;
  }
  

  • Les opérateurs peuvent être surchargés à l’intérieur de la classe, exemple :

  class A {
      ...
      A operator +(A a) { // un seul paramètre car l'autre est *this
          ...
          ...
          return ...;
      }
  };
  

  • Conversion implicite par constructeur :
    • SI A est une classe et E est l’identificateur d’un type alors un constructeur de la classe A(E\ a) définit une conversion implicite de E vers A.

• Héritages

  On peut utiliser le comportement d’une classe existante pour construire une nouvelle classe “modifiée”.

  Exemple

  struct Base { // classe de base ; classe mère
      void fonctionBase() { ... }
  };
  
  struct Derivee: public Base { // classe dérivée de la base ; classe fille
      int a;
  
      void fonctionDerivee() { ... }
  };
  
  int main(void) {
      Base objB;
      Derivee objD;
  
      objD.fonctionDerivee(); // oui ça fonctionne
      objD.fonctionBase();    // oui ça fonctionne
  
      objB.fonctionBase();       // oui ça fonctionne
      // objB.fonctionDerivee(); /* provoque une erreur
                                 /* pas de méthode dérivée
                                  * dans la classe de base. */
  
      return 0;
  }
  

  En mémoire

  Si B est la classe de base :
  
  Si D hérite de B avec :

  struct D: public B {
      int a1;
      int a2;
      int a3;
      // ...
      int ak;
  }
  

  

  Remarques

  • Les membres privés de la classe mère sont inaccessibles dans la classe fille. Par contre les membres publiques restent publiques.
  • Pas d’héritage des constructeurs (constructeurs de recopie), destructeur, opérateur d’affection. Par défaut ils sont générés à partir des méthodes de la classe de base.

  Exemple

  \rightarrow : hérite de…

  flowchart BT
  Soldat --> 1[Personnage]
  Architecte --> 1
  

  class Personnage {
      int pos_x;
      int pos_y;
      int pointVie;
  
      public:
          // Permet de se déplacer vers une nouvelle position
          void deplacer(int x, int y);
  
          // Diminiue les points de vie du personnage
          void prendDegat(int ptDegats);
  
          // ...
  };
  
  class Soldat: public Personnage {
      int puissance; // puissance d'attaque
  
      public:
          // Permet d'attaquer un autre personnage
          void attaque(Personnage &p) { // polymorphisme
              a.prendDegats(puissance);
          }
  };
  
  class Architecte: public Personnage {
      int efficacite; // efficacite a construire des bâtiments
  
      public:
          // Construit un bâtiment
          void construire();
  };
  
  int main(void) {
      Soldat s1;
      Soldat s2;
      Architecte a1;
      // ...
  
      s1.attaque(s2);
      s1.attaque(a1);
      // ...
  
      return 0;
  }
  

  Redéfinition

  • de méthode

  struct A {
      void f(void) {
          std::cout << "je suis un objet A" << std::endl;
      }
  
      void f(int a) {
          std::cout << "je suis un objet A " << a << std::endl;
      }
  
  };
  
  struct B: public A {
      void f(void) {
          std::cout << "je suis un objet B" << std::endl;
      }
  };
  
  int main(void) {
      A a;
      B b;
  
      a.f(); // affiche: je suis un objet A
      b.f(); // affiche: je suis un objet B
  
      b.f(3); // affiche: je suis un objet A 3
  
      return 0;
  }
  

  La redéfinition “cache” l’ancienne méthode. Elle est pourtant toujours accessible.

  Exemple : b.A::f(); -> “je suis un objet A”

  Remarque

  • Pour qu’il y ait redéfinition, il faut définir une méthode qui possède la même signature d’une méthode de la classe mère, sinon c’est une simple surcharge.
  • On peut aussi redéfinir des attributs

  Membres protected d’une classe

  Un membre d’une classe appartient à un et un seul des groupes suivants :

  • public
  • private
  • protected

  Un membre protected d’une classe M est inaccessible hors de la classe M sauf dans une méthode d’une classe dérivée de la classe M.

  Exemple

  class A {
      protected:
          int a;
      public:
          A(void) { ... }
  };
  
  class B: public A {
      /* ... */
  
      void f(void) {
          a = 3; // ok accès à un protected
      }
  
      /* ... */
  };
  
  int main(void) {
      A objA;
      B objB;
  
      // objA.a = 0; // erreur l'attribut a n'est pas accessible
      // objB.a = 1; // erreur l'attribut a n'est pas accessible
  
      return 0;
  }
  

  Autres types d’héritages en C++

  • héritage public
    • Les membres public de la classe mère devienne public dans la classe fille
    • Les membres protected de la classe mère devienne protected dans la classe fille`
    • Les membres private de la classe mère devienne inaccessible dans la classe fille
  • héritage protected
    • Les membres public de la classe mère devienne protected dans la classe fille
    • Les membres protected de la classe mère devienne protected dans la classe fille`
    • Les membres private de la classe mère devienne inaccessible dans la classe fille
  • héritage private
    • Les membres public de la classe mère devienne private dans la classe fille
    • Les membres protected de la classe mère devienne private dans la classe fille`
    • Les membres private de la classe mère devienne inaccessible dans la classe fille

  Appels aux constructeurs/destructeurs de la classe de base

  struct A {
      A(void) { ... } // constructeur A1
      A(int a) { ... } // constructeur A2
  };
  
  struct B: public A {
      int e;
      int d;
  
      /*        |-> tout ça c'est
       *        |   des initialisateurs
       *        \______________ */
      B(int i): A(i), e(3), d(7) { ... }
      /*        A(i) -> appel au
       *                constructeur
       *                A2 */
  };
  

  Conversions implicites

  Si la classe F hérite de M, alors tout objet de type F sera considéré comme un objet de type M (cf. exemple avec les personnages, soldats et architecte).

  Exemple

  F* pf = new F(...);
  M* pm = pf;
  // pf = pm; // erreur
  

  Si void m(void) est une méthode de M qui est redéfinie dans la classe F

  pm->m(); /* si void m(void)
            * n'est pas "virtual"
            * appel a void M::m(void) */
  

  Pour éviter ce comportement il faut déclarer m “virtual”.

  class M {
      virtual void m(void) { ... }
  };
  
  class F: public M {
      void m(void) { ... }
  };
  

  Ici le choix de la méthode m (qui est virtual) a partir d’un pointeur sera effectué à l’exécution et pas à la compilation.

• Fonction virtuelle et héritage multiple

  Fonction virtuelle

  Rappel

  graph TD
  B --> b1 & b2 & b3
  

  Si une classe D dérive de B, il existe une conversion implicite de D\star à B\star ainsi que de D\\\& à B\\\&.

  Exemple

  D* p = new D;
  B* pb = p;
  

  Pour les appels de fonction ?

  struct B {
      void f(void) { ... } // f1
      virtual void v(void) { ... } // v1
      void h(void) {
          ...
          v(); // équivalent à this->v(); ou (*this).v();
          ...
      }
  };
  
  struct D: public B {
      void f(void) { ... } // f2
      void v(void) { ... } // v2
  };
  
  int main(void) {
      B * p = new D;
      p->f(); // appel f1 car p est de type B
      p->v(); // appel v2 car v1 virtual
      p->h(); // appel v2 dans h
  
      return 0;
  }
  

  Pour f() le choix de la fonction est définie à la compilation.
  On peut forcer le compilateur a ne pas décider à la compilation et de laisser le choix à l’exécution avec le mot clé virtual comme fait pour v().

  -> Si une méthode est déclarée virtual alors toutes ses définitions seront virtual et le choix d’une méthode f à partir d’une adresse est fait :
  - à l’exécution si f est déclarée virtual
  - à la compilation selon le type de l’adresse si f n’est pas virtual

  Remarques

  Cette règle est aussi valable lorsqu’on utilise this (dans une méthode) explicitement ou implicitement.

  Fonction “virtuelle pure”

  On dit qu’une fonction est virtuelle pure si elle est déclarée sans être définie

  Exemple

  class A {
      virtual int maMethodeVirtuellePure(void) = 0;
      // virtual int maMethodeVirtuellePure(void); // -> erreur
  };
  

  Une classe qui possède une méthode virtuelle pure ne peut pas “fabriquer d’objet” (ne peut pas être instanciée). On dit que c’est une classe abstraite.

  Une classe dérivée d’une classe abstraite A peut-être instanciée seulement si elle définit chacune des méthodes virtuelles de A.

  Héritage multiple

  En C++ une classe peut dériver de plusieurs autre classes.

  Exemple

  class A { ... };
  
  class B { ... };
  
  class Mixe: public A, public B { ... };
  

  La nouvelle classe Mixe héritera des champs et des méthodes des deux classes A et B.

  En mémoire

  

  Construction, déstruction

  • Si une classe Mixe dérive de des classes A1, A2, A3, … dans cet ordre, les constructeurs des classes mères A1, A2 doient être appelé dans cet ordre et avant les constructeurs des nouveaux attributs définis dans Mixe.

  Exemple

  class Mixe: public A, public B {
      Mixe(...): A(...), B(...), attributs { ... };
  };
  

  • Par défaut, le déstructeur appelle les déstructeurs des classes mère dans l’ordre inverse de l’héritage.

  En reprenant l’exemple précédent, B est détruit, puis A lors de l’appel du destructeur de Mixe.

  Remarque

  Pour lever l’ambiguïté de deux membres ayant les mêmes nom/signature, on utilise ::

  Exemple

  int main(void) {
      Mixe m;
      m.A::attrib(..., B::attrib);
  
      return 0;
  }
  

• Exceptions, patrons de fonctions/classes et auto

  Exceptions

  Un morceau de code peu avoir un comportement variable selon le contexte.

  Exemple

  int 4 / b; // erreur si b == 0
  FILE * f = fopen("emplacement", 'r'); 
  

  Dans le cas ou le comportement n’est pas souhaité ou exceptionnel on dit qu’une exception est lancée/levée par le code. On peut “rattraper” l’exception avec une structure de contrôle de type try { /* ... */ } catch(/* ... */) { /* ... */ }

  Exemple

  using namespace std;
  
  int division(int a, int b) {
      if(b == 0)
  	    throw 1; // exception lancée
  	else
  		return a / b;
  }
  
  int main(void) {
      int val;
      int ret;
      
      cout << "Entrer un nombre" << endl;
      cin >> val;
      try {
  	    ret = division(43/val);
      } catch(int e) { // valeur throw = e
          if(e == 1) { // excpetion attrapée
               cout << "Impossible de diviser par zero" << endl;
               return 1;
          }
      }
      cout << "Le resultat de votre division est " << ret << endl;
      
      return 0;
  }
  

  Si une exception n’est récupéré à travers une structure de controle try catch elle est renvoyée à la fonction appelante si elle n’est capturée dans la fonction appelante elle est envoyée à la fonction appelante de la fonction appelante .

  Si elle n’est n’est jamais capturée alors le programme s’interrompt brutalement (ducoup ce serait comme un exit(n).

  On peut cumuler les blocs catch. Si le code est suceptible de lever plusieurs exceptions. Le bloc qui est choisi est le premier qui “correspond” au type de l’exception lancée.

  La correspondance est définie par :

  • correspondance exacte de type
  • si conversion implicite par héritage

  Exemple

  struct A { /*...*/ };
  
  struct B: public A { /*...*/ };
  try {
      B b;
      throw b; // ligne 6
  } catch(long c) {
      /* Pas exécuté car B != long */
  } catch(A a) {
      /* Récupére l'objet lancé  en ligne 6 */
  } catch(B b) {
      /* Ne sera jamais exécuté */
  }
  

  Le bloc catch(...) (c’est bien trois point) récupère toute exception non interceptée par les blocs catch précédents.

  Exemple

  try {
      throw 1; // int est envoyé
  } catch(long a) {
      /* Jamais exécuté */
  } catch(...) { // c'est bien trois points  
      /* Toujours exécuté */
  }
  

  On peut indiquer qu’une fonction ne renvoie pas d’exception en utilisant le mot clé noexcept.

  Exemple

  int addition(int a, int b) noexcept {
      return a + b;
  }
  

  Patron de fonctions de classe

  Définition

  Un patron de fonction (ou template) est une définition d’une fonction où un des paramètre est un type.

  Exemple

  // Exemple que l'on a fait en Algo et struct de données 2
  template<class T>
  T max(T a, T b) {
      if(a > b)
          return a;
      else
          return b;
  }
  
  // Exemple donnée pendant le cours de POO
  template<typename T> max(T a, T b) {
      if(a > b)
          return a;
      else
          return b;
  }
  
  max<int>   (3, 4);
  max<float> (3.1, 6.7);
  

  Lors d’un appel à un patron de fonction le compilateur génère le code de la fonction selon les arguments “types”. Pour cette raison les patron de fonction sont a définir dans les fichiers d’entête (fichier.h) et ne sont pas présent dans les fichiers objet (fichier.o)

  On peut faire des patron de méthode/opérateur.

  Lors d’un appel d’un patron de fonction les arguments “types” peuvent être omis dans ce cas le compilateur essaye de les trouver par unification.

  Exemple

  // types identique
  max(3, 4); // ok ici équivalent à max<int>(3,4);
  
  // Types différents
  // max(3, 4l) // erreur ambiguité 
  max<long>(3, 4l); // Ok 
  

  On peut préciser plusieurs paramètres : template<typename A, typename B> A f(B a, int c);

  Patron de classe

  On peut créer des patrons de classe. Dans ce cas les arguments “types” doivent être explicites.

  Exemple

  struct B{ /*...*/ };
  
  /* Définition */
  template<typename T> struct maClVar {
      /* ... */
      
      T machin(int a);
  };
  
  /* Utilisation */
  maClVar<int> a;
  maClVar<maClVar<B>> d;
  
  template<typename T> T maClVar<T>::machin(int a){ /*...*/}
  

  Les paramètres de patron/fonction peuvent être des valeurs connues à la compilation.

  Exemple

  template<int a>
  int f(int a) {
      return a * b;
  }
  
  int main(void) {
      int b;
      std::cin >> b;
      std::cout << f<3>(b); // ok
      //std::cout << f<b>(3); // erreur
  }
  

  Le mot clé auto

  On peut définir une variable avec auto si le contexte permet d’établir le type de la variable à la compilation.

  Exemple

  auto a = 3; // variable a de type int
  auto b = 3.; // variable b de tybe double
  //auto c; // erreur
  

• STL

  La STL est la bibliothèque standard de C++. Les identifiants de la STL sont créés dans l’espace de nom std.

  Patron de classe array

  Tableau de taille fixe

  #include <array>
  
  using namespace std;
  
  int main(void) {
      // type et taille
      array<int, 4> ar = {1, 2, 3};
  
      int c = ar[0]; // attention : pas d'exception
      ar[3] = 6;     // en cas d'erreur d'indice
      ar.at(1); // exception "out_of_range" lancée en cas d'erreur d'indice
      ar.size(); // renvoie la taille de l'array = 4 ici
  
      return 0;
  }
  

  Patron de classe vector

  Tableau de taille variable/dynamique

  #include <vector>
  
  using namespace std;
  
  int main(void) {
      vector<float> = vec{1., 2, 6, -3};
  
      vec[0]; // accesseur, pas d'exception (comme array)
      vec.at(1); // gère les erreurs d'indices (comme array)
      vec.size(); // taille du vecteur, ici 4
      vec.push_back(25); // ajoute une case à la, fin
      vec.pop_back(); // retire et renvoie la valeur de la case de fin
      vec.insert(3, 7.5); /* place 7.5 dans la case d'indice 3 et décale
                           * les valeurs des cases d'indice supérieurs de 1 */
      vec.insert(2, 3, 6.5); // 3 est le nombre de cases ajoutés
  
      return 0;
  }
  

  

  Itérateur

  On dit qu’une variable est un itérateur si on peut appliquer les opérateurs :

  • ++it / it++
  • --it / it--
  • +it
  • it1 != it2
  • it1 == it2

  Les classes array et vector peuvent produire des itérateurs avec les méthodes begin() et end().

  Exemple avec array (fonctionne pareil avec vector)

  #include <array>
  
  using namespace std;
  
  int main(void) {
      array<int, 4> ar = {1, 2, 3, 4};
  
      auto debut = ar.begin();
      auto fin = ar.end();
  
      for(; debut != fin; debut++) // affiche le contenu de l'array
          cout << *debut << endl;
  
      // On peut raccourci le code au dessus en faisant ceci :
      for(int var = arr)
          cout << var << endl;
  
      return 0;
  }
  

  Patron de classe map

  #include <string> // indépendant de map, juste pour l'exemple
  #include <map>
  
  using namespace std;
  
  int main(void) {
      map<int, string> dico = {
          {0, "bonjour"},  // 0 -> "bonjour"
          {1, "au revoir"} // 1 -> "au revoir"
      };
  
      dico[3] = string("trois"); // ajout : 3 -> "trois"
      dico[1] = string("zero");  // donc désormais, 1 -> "zero"
  
      map<string, int> retour;
  
      retour["zero"] = 7;     // "zero" -> 7
      int c = retour["zero"]; // ici : c = 7
      retour["un"] = 4;       // "un" -> 4
      retour["zero"] = 5;     // modifications : "zero" -> 5
  
      return 0;
  }
  

  • Pour fabriquer un objet map, il faut que l’on puisse comparer (égale ou différent) des objets.
  • Chaque opération élémentaire doit se faire en moins de \Theta(log(n)) où n est le nombre de clés dans l’objet.
  • Il faut que les instances du types des clés puissent être comparés (< ou >)
  • Les classes vector et map possèdent les méthodes :
    • clear() qui retire tous les éléments
    • empty() qui renvoie 1 si aucun élément

  Exemple

  map<..., ...> m;
  m[...] = ...;
  m.clear();
  
  // ici -> m.size() == 0;
  // m.empty() == true; // la map est "vide"
  

• Mémoire

  Déplacement d’objet avec std::move

  struct A {
      // Constructeur
      A() { /* ... */ }
  

  

      // Constructeur de recopie
      A(const A &s) { /* ... */ }
  
      // Opérateur d'assignation
      A& operator=(const A& s) { /* ... */ }
  

  

      // Destructeur
      ~A() { /* ... */ }
  };
  

  

  #include <utility> // pour std::move(/* ... */);
  
  int main(void) {
      vector<std::string> v;
      std::string s;
  
      while(s != "END") {
          std::cin >> s;
          // v.push_back(s);
          v.push_back(std::move(s));
      }
  }
  

  

  On peut utiliser move !

  Autre exemple :

  std::string a = "Bonjour";
  std::string b = "Machin";
  std::string c = "truc";
  
  a = b;
  // a contient "Machin"
  // b contient "Machin"
  
  c = std::move(b);
  // c contient "Machin"
  // b contient la chaîne vide
  

  std::move a un interêt quand il faut déplacer une ressource sans tout copier.

  Pour pouvoir l’utiliser dans notre classe, il faut implanter un autre constructeur de recopie ainsi qu’un autre constructeur d’assignation : (appellé respectivement constructeur de déplacement et l’opérateur de déplacement)

  A(const A&& s) { /* ... */}
  A& operator=(const A&& s) { /* ... */}
  

  (on double la référence)

  Conclusion

  Afin de pouvoir optimiser certaines instructions sur une classe A. On peut implanter le constructeur de déplacement (A(const A&&)) et l’assignation par déplacement (A& operator=(const A&&)) que l’on utilisera avec std::move() de <utility>.

  Exemple d’implantation
  On suppose que
  - on a un pointeur vers un int qui va pointer vers une zone mémoire que l’on va allouer dynamiquement)
  - on a une classe Mere déjà définit

  #include <utility>
  
  using namespace std;
  
  struct Fille: public Mere {
       int * p = NULL;
  
      // Constructeur qui ne fait rien
      Fille(void) { }
  
      // Constructeur qui alloue de la mémoire
      Fille(int a): Mere(a) {
          p = malloc(sizeof(*p) * 100); // il va falloir free cette allocation
                                        // lors de la déstruction
          for(int i = 0; i < 100; i++) {
              p[i] = i;
          }
      }
  
      // Destructeur qui désalloue la mémoire alloué lors de la construction
      ~Fille(): ~Mere() {
          if(p != NULL) {
              free(p);
          }
      }
  
      // Constructeur de copie
      Fille(const Fille& s): Mere(s) {
          if(s.p != NULL) { // Dans ce cas là on fait une allocation
              p = malloc(sizeof(*p) * 100);
              for(int i = 0; i < 100; i++) {
                  p[i] = s.p[i];
              }
          }
      }
  
      // Affectation/Assignation
      Fille& operator=(const Fille& s) {
          (*this).Mere::operator(s); // on appelle celui de la classe Mere
          if(s.p == NULL) { // si s.p est NULL
              if(p != NULL) { // mais que p l'est pas, on libère p
                  free(p);
                  p = NULL;
              }
          } else { // sinon si s.p n'est pas NULL
              if(p == NULL) { // on alloue la mémoire si besoin
                  p = malloc(sizeof(*p) * 100);
              }
              for(int i = 0; i < 100; i++) { // on recopie les valeurs
                  p[i] = s.p[i];
              }
          }
  
          return *this;
      }
  
      // Constructeur de déplacement
      Fille(const Fille&& s): Mere(move(s)) {
          p = s.p; // déplacement
          s.p = NULL; // ancienne emplacement est désormais NULL
      }
  
      // Affectation de déplacement
      Fille& operator=(const Fille&& s) {
          // Partie mère
          (*this).Mere::operator=(move(s));
  
          // Partie Fille
          if(p != NULL) {
              free(p);
          }
          p = s.p;
          s.p = NULL;
  
          return *this;
      }
  };
  

  Appel du constructeur d’une classe sans réservation de mémoire

  Allocation de mémoire, puis appel du constructeur d’une classe A :

  A a;
  A * p = new A;
  

  Pour appeller un constructeur d’une classe A sur une adresse addr (sans allocation de mémoire) on peut utiliser la syntaxe :

  new(addr) A{ /* ... */ }; // appel du constructeur `A` à l'adresse `addr`
  

  Exemple

  void * ptr = malloc(sizeof(*ptr)); // réservation de la mémoire
  
  A * c = new(ptr) A{ /* ... */ }; // appel au constructeur sans réservation mémoire
  
  // ...
  
  (*c).~A(); // appel au destructeur sans libération de la mémoire alloué plus haut
  free(ptr);
  

  Utile lorsque l’on ne veut réallouer plusieurs fois de la mémoire.

  Cast dynamique

  En C++, il y a plusieurs moyen de faire des conversions.
  En C : (type)expression;
  En C++ :

  • const_cast<type>(expression);
  • reinterpret_cast<type>(expression);
  • static_cast<type>(expression);
  • dynamic_cast<type>(expression);
    • Va servir lorsque l’on a une adresse vers une classe mère mais on ne sait pas si c’est l’objet mère ou un objet fille.

  Exemple dynamic_cast<>()

  Mere * p = new Fille( /* ... */);
  Fille * c = dynamic_cast<Fille>(p); // au moment de l'execution, NULL si ce n'est
                                      // pas une fille ou un type hérité de fille
  if(c == NULL) {
      cout << "N'est pas une fille" << endl;
  } else {
      cout << "Est une fille" << endl;
  }
  // Ce code affichera toujours "Est une fille"