Partage
  • Partager sur Facebook
  • Partager sur Twitter

Ordre d'appel des constructeurs

lors d'un héritage de classes (tuto m@teo)

Sujet résolu
    19 septembre 2007 à 22:25:13

    Bonjour ! :)
    Petite demande d'information toute bête. Je pense que le problème seera vite résolu ^^.

    Voilà sur le tuto, M@teo explique que lors d'un héritage de classes A -> B (B hérite de A), le constructeur de A sera appelé avant le constructeur de B.

    Citation : M@teo

    1. Vous demandez à créer un objet de type Magicien
    2. Le compilateur appelle d'abord le constructeur de la classe mère (Personnage)
    3. Puis, le compilateur appelle le constructeur de la classe fille (Magicien)



    Puis la suite du tuto explique comment faire pour appeler le constructeur de A avant le constructeur de B. :o

    Alors ma question est : si on ne fait pas le "comment faire" en question, le constructeur de A sera bel et bien appelé, non ? Pas seulement celui de B ? (autrement dit : le constructeur de A sera-t-il de toutes manières appelé ?)

    Ainsi, l'opération suivante :
    1. Magicien::Magicien() : Personnage(), mana(100)
    2. {
    3. }


    ... n'a-t-elle que pour seule utilité d'appeler un autre constructeur que celui par défaut ?

    Merci de m'éclairer, ce n'est pas vraiment la résolution d'un problème, mais un doute qui m'a faire relire trois fois ce passage dans le tuto, en ayant la certitude que M@teo nous expliquait comment faire quelquechose qui se fait tout seul normalement. :euh:

    Bonne soirée ^^.
    • Partager sur Facebook
    • Partager sur Twitter
      19 septembre 2007 à 22:39:31

      Le mielleur moyen pour voir ça, c'est de mettre des cout dans les methodes pour voir quand il y passe :)

      1. #include <iostream>
      2. class A
      3. {
      4. public:
      5.         A()  // A(int i)
      6.         {
      7.                 std::cout << "appel de A" << std::endl;
      8.         }
      9. };
      10. class B : public A
      11. {
      12. public:
      13.         B()
      14.         {
      15.                 std::cout << "appel de B" << std::endl;
      16.         }
      17. };
      18. int main()
      19. {
      20.         B b;
      21.         return 0;
      22. }


      Ce petit exemple montre que le constructeur de B appelle celui de A avant :)

      Si tu regardes la ligne que j'ai mis en commentaire (changer le prototype du constructeur de A avec un parametre), alors le compilo gueule : il demande le constructeur par défaut de A :)

      En fait, si tu ne mets pas explicitement
      B:A(...)
      comme apres le constructeur de la classe fille, les constructeur par défaut sont appelés :)

      C'est pour cela aussi qu'une classe normalisée doit normalement bien contenir :
      - constructeur par defaut
      - constructeur par recopie
      - destructeur
      - surcharge du =

      (tu peux éventuellement te passer des 3 derniers si tous les membres se recopient facilement a coup de = et qu'ils se détruisent tout seul, mais le constructeur par défaut est important je dirais ! (a moins bien sur que tu veuilles volontairement interdire une création "par défaut")
      • Partager sur Facebook
      • Partager sur Twitter

      Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

        19 septembre 2007 à 23:02:49

        Je vois, donc le constructeur par défaut est bel et bien appelé... parr défaut ^^.
        Merci, ça enlève mes doutes ^^.
        • Partager sur Facebook
        • Partager sur Twitter

        Ordre d'appel des constructeurs

        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
        × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
        • Editeur
        • Markdown