Kann ich in C++ einen Konstruktor von einem anderen Konstruktor aus aufrufen (Konstruktorverkettung durchführen)?

Question

Als C# Entwickler bin ich es gewohnt, Konstruktoren zu durchlaufen:

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

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

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

Gibt es eine Möglichkeit, dies in C++ zu tun?

Ich habe versucht, den Klassennamen aufzurufen und das Schlüsselwort "this" zu verwenden, aber beides schlägt fehl.

Answer 1

C++11: Ja!

Ab C++11 gibt es die gleiche Funktion (genannt delegierende Konstrukteure ).

Die Syntax unterscheidet sich geringfügig von C#:

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

C++03: Nein

Leider gibt es keine Möglichkeit, dies in C++03 zu tun, aber es gibt zwei Möglichkeiten, dies zu simulieren:

1. Sie können zwei (oder mehr) Konstruktoren über Standardparameter kombinieren:

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

2. Verwenden Sie eine init-Methode, um gemeinsamen Code zu teilen:

   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)
   {
     // ...
   }

Siehe der C++FAQ-Eintrag als Referenz.

Answer 2

Ja und Nein, je nachdem, welche Version von C++.

In C++03 kann man einen Konstruktor nicht von einem anderen Konstruktor aus aufrufen (ein sogenannter delegierender Konstruktor).

Dies änderte sich in C++11 (auch bekannt als C++0x), das die Unterstützung für die folgende Syntax hinzufügte:
(Beispiel entnommen aus Wikipedia )

class SomeType
{
  int number;

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

Answer 3

Ich glaube, Sie können einen Konstruktor von einem Konstruktor aus aufrufen. Er wird kompiliert und ausgeführt. Ich habe kürzlich gesehen, wie jemand dies getan hat, und es lief sowohl unter Windows als auch unter Linux.

Es tut einfach nicht das, was Sie wollen. Der innere Konstruktor konstruiert ein temporäres lokales Objekt, das gelöscht wird, sobald der äußere Konstruktor zurückkehrt. Es müssten auch unterschiedliche Konstruktoren sein, oder Sie würden einen rekursiven Aufruf erzeugen.

Ref: https://isocpp.org/wiki/faq/ctors#init-methods

Answer 4

C++11 : Ja!

Ab C++11 gibt es die gleiche Funktion (genannt delegierende Konstrukteure ).

Die Syntax unterscheidet sich geringfügig von C#:

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

C++03 : Nein

Es ist darauf hinzuweisen, dass Sie puede den Konstruktor einer übergeordneten Klasse in Ihrem Konstruktor aufrufen, z.B.:

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

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

Aber nein, bis C++03 kann man keinen anderen Konstruktor der gleichen Klasse aufrufen.

Answer 5

Unter C++11 , a Konstruktor kann eine andere Konstruktorüberladung aufrufen :

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

Außerdem können Mitglieder auch auf diese Weise initialisiert werden.

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

Dadurch sollte es nicht mehr notwendig sein, die Initialisierungshilfsmethode zu erstellen. Und es wird immer noch empfohlen, keine virtuellen Funktionen in den Konstruktoren oder Destruktoren aufzurufen, um die Verwendung von Mitgliedern zu vermeiden, die möglicherweise nicht initialisiert sind.