Puis-je appeler un constructeur à partir d'un autre constructeur (faire du chaînage de constructeurs) en C++ ?

Question

En tant que C# développeur je suis habitué à courir à travers les constructeurs :

class Test {
    public Test() {
        DoSomething();
    }

    public Test(int count) : this() {
        DoSomethingWithCount(count);
    }

    public Test(int count, string name) : this(count) {
        DoSomethingWithName(name);
    }
}

Existe-t-il un moyen de faire cela en C++ ?

J'ai essayé d'appeler le nom de la classe et d'utiliser le mot-clé "this", mais les deux échouent.

Answer 1

C++11 : Oui !

Les versions C++11 et ultérieures disposent de cette même fonctionnalité (appelée délégation des constructeurs ).

La syntaxe est légèrement différente de celle du C# :

class Foo {
public: 
  Foo(char x, int y) {}
  Foo(int y) : Foo('a', y) {}
};

C++03 : Non

Malheureusement, il n'y a aucun moyen de le faire en C++03, mais il y a deux façons de le simuler :

1. Vous pouvez combiner deux constructeurs (ou plus) via des paramètres par défaut :

   class Foo {
   public:
     Foo(char x, int y=0);  // combines two constructors (char) and (char, int)
     // ...
   };

2. Utilisez une méthode init pour partager un code commun :

   class Foo {
   public:
     Foo(char x);
     Foo(char x, int y);
     // ...
   private:
     void init(char x, int y);
   };
   
   Foo::Foo(char x)
   {
     init(x, int(x) + 7);
     // ...
   }
   
   Foo::Foo(char x, int y)
   {
     init(x, y);
     // ...
   }
   
   void Foo::init(char x, int y)
   {
     // ...
   }

Ver l'entrée C++FAQ pour référence.

Answer 2

Oui et non, selon la version de C++.

En C++03, vous ne pouvez pas appeler un constructeur à partir d'un autre (appelé constructeur de délégation).

Cela a changé dans le C++11 (alias C++0x), qui a ajouté la prise en charge de la syntaxe suivante :
(exemple tiré de Wikipedia )

class SomeType
{
  int number;

public:
  SomeType(int newNumber) : number(newNumber) {}
  SomeType() : SomeType(42) {}
};

Answer 3

Je crois que vous pouvez appeler un constructeur à partir d'un constructeur. Il sera compilé et exécuté. J'ai récemment vu quelqu'un faire cela et cela a fonctionné à la fois sur Windows et Linux.

Il ne fait tout simplement pas ce que vous voulez. Le constructeur interne construira un objet local temporaire qui sera supprimé dès le retour du constructeur externe. Il faudrait aussi qu'ils soient des constructeurs différents, sinon vous créeriez un appel récursif.

Réf : https://isocpp.org/wiki/faq/ctors#init-methods

Answer 4

C++11 : Oui !

Les versions C++11 et ultérieures disposent de cette même fonctionnalité (appelée délégation des constructeurs ).

La syntaxe est légèrement différente de celle du C# :

class Foo {
public: 
  Foo(char x, int y) {}
  Foo(int y) : Foo('a', y) {}
};

C++03 : Non

Il est utile de souligner que vous peut appeler le constructeur d'une classe parente dans votre constructeur, par exemple :

 class A { /* ... */ };

    class B : public A
    {
        B() : A()
        {
            // ...
        }
    };

Mais, non, vous ne pouvez pas appeler un autre constructeur de la même classe jusqu'à C++03.

Answer 5

Sur C++11 , a Le constructeur peut appeler une surcharge d'un autre constructeur :

class Foo  {
     int d;         
public:
    Foo  (int i) : d(i) {}
    Foo  () : Foo(42) {} //New to C++11
};

De plus, les membres peuvent être initialisés de cette manière.

class Foo  {
     int d = 5;         
public:
    Foo  (int i) : d(i) {}
};

Cela devrait éliminer la nécessité de créer la méthode d'aide à l'initialisation. Et il est toujours recommandé de ne pas appeler de fonctions virtuelles dans les constructeurs ou les destructeurs pour éviter d'utiliser des membres qui pourraient ne pas être initialisés.