Quelles sont les règles pour appeler le constructeur de la classe de base ?

Question

Quelles sont les règles C++ pour appeler le constructeur de la classe de base depuis une classe dérivée ?

Par exemple, je sais qu'en Java, vous devez le faire en tant que première ligne du constructeur de la sous-classe (et si vous ne le faites pas, un appel implicite à un super constructeur sans argument est supposé - ce qui vous donne une erreur de compilation si cela manque).

Answer 1

Les constructeurs des classes de base sont automatiquement appelés pour vous s'ils n'ont pas d'argument. Si vous voulez appeler un constructeur de superclasse avec un argument, vous devez utiliser la liste d'initialisation du constructeur de la sous-classe. Contrairement à Java, le C++ prend en charge l'héritage multiple (pour le meilleur et pour le pire), de sorte que la classe de base doit être désignée par son nom, plutôt que par "super()".

class SuperClass
{
    public:

        SuperClass(int foo)
        {
            // do something with foo
        }
};

class SubClass : public SuperClass
{
    public:

        SubClass(int foo, int bar)
        : SuperClass(foo)    // Call the superclass constructor in the subclass' initialization list.
        {
            // do something with bar
        }
};

Plus d'infos sur la liste d'initialisation du constructeur aquí y aquí .

Answer 2

En C++, les constructeurs sans argument de toutes les superclasses et variables membres sont appelés pour vous, avant d'entrer dans votre constructeur. Si vous souhaitez leur passer des arguments, il existe une syntaxe distincte pour cela, appelée "enchaînement de constructeur", qui ressemble à ceci :

class Sub : public Base
{
  Sub(int x, int y)
  : Base(x), member(y)
  {
  }
  Type member;
};

Si un élément exécuté à ce stade échoue, les bases/membres qui avaient précédemment terminé la construction voient leurs destructeurs appelés et l'exception est renvoyée à l'appelant. Si vous voulez attraper les exceptions pendant le chaînage, vous devez utiliser un bloc try de fonction :

class Sub : public Base
{
  Sub(int x, int y)
  try : Base(x), member(y)
  {
    // function body goes here
  } catch(const ExceptionType &e) {
    throw kaboom();
  }
  Type member;
};

Dans cette forme, notez que le bloc try es le corps de la fonction, plutôt que d'être à l'intérieur du corps de la fonction ; cela lui permet de capturer les exceptions lancées par les initialisations implicites ou explicites des membres et des classes de base, ainsi que pendant le corps de la fonction. Toutefois, si un bloc de capture de fonction ne lève pas une exception différente, le runtime relancera l'erreur originale ; les exceptions pendant l'initialisation ne peut pas être ignorée.

Answer 3

En C++, il existe un concept de liste d'initialisation du constructeur, qui est l'endroit où vous pouvez et devez appeler le constructeur de la classe de base et où vous devez également initialiser les membres de données. La liste d'initialisation vient après la signature du constructeur après un deux-points, et avant le corps du constructeur. Disons que nous avons une classe A :

class A : public B
{
public:
  A(int a, int b, int c);
private:
  int b_, c_;
};

Ensuite, en supposant que B a un constructeur qui prend un int, le constructeur de A peut ressembler à ceci :

A::A(int a, int b, int c) 
  : B(a), b_(b), c_(c) // initialization list
{
  // do something
}

Comme vous pouvez le voir, le constructeur de la classe de base est appelé dans la liste d'initialisation. L'initialisation des membres de données dans la liste d'initialisation est d'ailleurs préférable à l'affectation des valeurs de b_ et c_ dans le corps du constructeur, car vous économisez le coût supplémentaire de l'affectation.

Gardez à l'esprit que les membres des données sont toujours initialisés dans l'ordre dans lequel ils sont déclarés dans la définition de la classe, indépendamment de leur ordre dans la liste d'initialisation. Pour éviter des bogues étranges, qui peuvent survenir si vos membres de données dépendent les uns des autres, vous devez toujours vous assurer que l'ordre des membres est le même dans la liste d'initialisation et dans la définition de la classe. Pour la même raison, le constructeur de la classe de base doit être le premier élément de la liste d'initialisation. Si vous l'omettez complètement, le constructeur par défaut de la classe de base sera appelé automatiquement. Dans ce cas, si la classe de base n'a pas de constructeur par défaut, vous obtiendrez une erreur de compilation.

Answer 4

Si vous avez un constructeur sans arguments, il sera appelé avant que le constructeur de la classe dérivée ne soit exécuté.

Si vous voulez appeler un constructeur de base avec des arguments, vous devez l'écrire explicitement dans le constructeur dérivé comme ceci :

class base
{
  public:
  base (int arg)
  {
  }
};

class derived : public base
{
  public:
  derived () : base (number)
  {
  }
};

En C++, vous ne pouvez pas construire une classe dérivée sans appeler le constructeur des parents. Soit cela se produit automatiquement si c'est un C'tor sans argument, soit cela se produit si vous appelez le constructeur dérivé directement comme indiqué ci-dessus ou votre code ne compilera pas.

Answer 5

La seule façon de transmettre des valeurs à un constructeur parent est de passer par une liste d'initialisation. La liste d'initialisation est implémentée avec un : et ensuite une liste de classes et les valeurs à passer au constructeur de cette classe.

Class2::Class2(string id) : Class1(id) {
....
}

Rappelez-vous également que si vous avez un constructeur qui ne prend aucun paramètre sur la classe parent, il sera appelé automatiquement avant l'exécution du constructeur enfant.