Appel de fonctions virtuelles dans les constructeurs

Question

Supposons que j'ai deux classes C++ :

class A
{
public:
  A() { fn(); }

  virtual void fn() { _n = 1; }
  int getn() { return _n; }

protected:
  int _n;
};

class B : public A
{
public:
  B() : A() {}

  virtual void fn() { _n = 2; }
};

Si j'écris le code suivant :

int main()
{
  B b;
  int n = b.getn();
}

On pourrait s'attendre à ce que n est réglé sur 2.

Il s'avère que n est fixé à 1. Pourquoi ?

Answer 1

L'appel de fonctions virtuelles à partir d'un constructeur ou d'un destructeur est dangereux et doit être évité dans la mesure du possible. Toutes les implémentations C++ doivent appeler la version de la fonction définie au niveau de la hiérarchie dans le constructeur actuel et pas au-delà.

Le site FAQ C++ Lite couvre ce sujet dans la section 23.7 de manière assez détaillée. Je vous suggère de la lire (ainsi que le reste de la FAQ) pour un suivi.

Extrait :

[...] Dans un constructeur, le mécanisme d'appel virtuel est désactivé parce que la surcharge des classes dérivées n'a pas encore eu lieu. Les objets sont construits à partir de la base, "la base avant les dérivés".

[...]

La destruction se fait "la classe dérivée avant la classe de base", donc les fonctions virtuelles se comportent comme des constructeurs : Seules les définitions locales sont utilisées - et aucun appel n'est fait aux fonctions de surcharge pour éviter de toucher la partie de l'objet qui appartient à la classe dérivée (maintenant détruite).

EDIT Corrigé Most to All (merci litb)

Answer 2

L'appel d'une fonction polymorphe à partir d'un constructeur est une recette pour un désastre dans la plupart des langages OO. Les différents langages se comportent différemment lorsque cette situation se présente.

Le problème de base est que dans tous les langages, le ou les types de base doivent être construits avant le type dérivé. Maintenant, le problème est de savoir ce que cela signifie d'appeler une méthode polymorphe à partir du constructeur. Comment voulez-vous qu'elle se comporte ? Il existe deux approches : appeler la méthode au niveau de la base (style C++) ou appeler la méthode polymorphe sur un objet non construit au bas de la hiérarchie (style Java).

En C++, la classe de base construit sa version de la table des méthodes virtuelles avant d'entrer dans sa propre construction. À ce stade, un appel à la méthode virtuelle finira par appeler la version de la méthode de la classe de base ou par produire un message de type une méthode virtuelle pure appelée au cas où il n'y aurait pas d'implémentation à ce niveau de la hiérarchie. Après la construction complète de la base, le compilateur commencera à construire la classe dérivée, et il remplacera les pointeurs de méthode pour pointer vers les implémentations du niveau suivant de la hiérarchie.

class Base {
public:
   Base() { f(); }
   virtual void f() { std::cout << "Base" << std::endl; } 
};
class Derived : public Base
{
public:
   Derived() : Base() {}
   virtual void f() { std::cout << "Derived" << std::endl; }
};
int main() {
   Derived d;
}
// outputs: "Base" as the vtable still points to Base::f() when Base::Base() is run

En Java, le compilateur construit l'équivalent de la table virtuelle à la toute première étape de la construction, avant d'entrer dans le constructeur de base ou le constructeur dérivé. Les implications sont différentes (et à mon avis plus dangereuses). Si le constructeur de la classe de base appelle une méthode qui est surchargée dans la classe dérivée, l'appel sera en fait traité au niveau dérivé en appelant une méthode sur un objet non construit, ce qui donne des résultats inattendus. Tous les attributs de la classe dérivée qui sont initialisés dans le bloc constructeur ne sont pas encore initialisés, y compris les attributs "finaux". Les éléments qui ont une valeur par défaut définie au niveau de la classe auront cette valeur.

public class Base {
   public Base() { polymorphic(); }
   public void polymorphic() { 
      System.out.println( "Base" );
   }
}
public class Derived extends Base
{
   final int x;
   public Derived( int value ) {
      x = value;
      polymorphic();
   }
   public void polymorphic() {
      System.out.println( "Derived: " + x ); 
   }
   public static void main( String args[] ) {
      Derived d = new Derived( 5 );
   }
}
// outputs: Derived 0
//          Derived 5
// ... so much for final attributes never changing :P

Comme vous pouvez le constater, l'appel d'une fonction polymorphe ( virtuel dans la terminologie du C++) est une source courante d'erreurs. En C++, vous avez au moins la garantie que l'on n'appellera jamais une méthode sur un objet encore non construit...

Answer 3

La raison en est que les objets C++ sont construits comme des oignons, de l'intérieur vers l'extérieur. Les classes de base sont construites avant les classes dérivées. Ainsi, avant qu'un B puisse être construit, un A doit être construit. Lorsque le constructeur de A est appelé, ce n'est pas encore un B, donc la table des fonctions virtuelles contient toujours l'entrée pour la copie de fn() de A.

Answer 4

Le site FAQ C++ Lite Couvre ça plutôt bien :

Essentiellement, lors de l'appel au constructeur de la classe de base, l'objet n'est pas encore du type dérivé et donc l'implémentation de la fonction virtuelle du type de base est appelée et non celle du type dérivé.

Answer 5

Une solution à votre problème consiste à utiliser des méthodes de fabrique pour créer votre objet.

• Définissez une classe de base commune pour votre hiérarchie de classes contenant une méthode virtuelle afterConstruction() :

  class Object { public: virtual void afterConstruction() {} // ... };

• Définir une méthode d'usine :

  template< class C > C* factoryNew() { C* pObject = new C(); pObject->afterConstruction();

  return pObject; }

• Utilisez-le comme ça :

  class MyClass : public Object { public: virtual void afterConstruction() { // do something. } // ... };

  MyClass* pMyObject = factoryNew();