Kann ich einen Konstruktor von einem anderen Konstruktor (do constructor chaining) in C ++ aufrufen?

C++11: Ja!

C++11-und weiter hat dieser selbe feature (genannt delegierende Konstruktoren).

Die syntax unterscheidet sich etwas von C#:

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

C++ - 03: Keine

Leider gibt es keine Möglichkeit, dies zu tun in C++03, aber es gibt zwei Arten der Simulation:

1. Können Sie kombinieren zwei (oder mehrere) Konstruktoren per default Parameter:

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

2. Nutzen Sie eine init-Methode, um gemeinsamen code:

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

Sehen der C++ - FAQ-Eintrag für Referenz.

InformationsquelleAutor der Antwort JohnIdol

Ich glaube, Sie können rufen Sie einen Konstruktor aus einem Konstruktor. Es wird kompiliert und ausgeführt. Vor kurzem sah ich jemanden, dies zu tun und es lief auf Windows und Linux.

Es einfach nicht tun, was Sie wollen. Die innere Konstruktor konstruieren ein lokales temporäres Objekt, das gelöscht wird, sobald die äußeren Konstruktor gibt. Werden, müssten Sie verschiedene Konstruktoren, wie gut oder erstellen Sie einen rekursiven Aufruf.

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

InformationsquelleAutor der Antwort ohlemacher

In C++11ein Konstruktor kann einen anderen Konstruktor aufrufen überlastung:

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

Zusätzlich können Mitglieder werden initialisiert, wie dies auch.

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

Sollte dies die Notwendigkeit beseitigen, die zum erstellen der Initialisierung Helfer-Methode. Und es ist immer noch empfohlen, nicht durch Aufruf einer virtuelle Funktionen in Konstruktoren oder Destruktoren zu vermeiden, mit allen Mitgliedern, die möglicherweise nicht initialisiert werden.

InformationsquelleAutor der Antwort Ben L

Nein, in C++ können Sie nicht aufrufen eines Konstruktors aus einem Konstruktor. Was Sie tun können, als warren darauf hingewiesen, ist:

• Überladen Sie den Konstruktor, mit verschiedenen Signaturen
• Verwenden Sie die Standard-Werte auf Argumente, um eine "einfachere" version verfügbar

Beachten Sie, dass im ersten Fall, können Sie nicht reduzieren, code-Duplizierung, die durch den Aufruf eines Konstruktors aus einem anderen. Sie können natürlich eine eigene, private/protected-Methode, die macht die ganze Initialisierung, und lassen Sie den Konstruktor befassen sich hauptsächlich mit der Behandlung von Argumenten.

InformationsquelleAutor der Antwort unwind

Wenn ich verstehe deine Frage richtig, du bist gefragt, wenn Sie anrufen können mehrere Konstruktoren in C++?

Wenn es das ist, was Sie suchen, dann Nein - das ist nicht möglich.

Können Sie in der Tat haben mehrere Konstruktoren, die jeweils mit einzigartigen argument Unterschriften, und dann rufen Sie die, die Sie wollen, wenn Sie instanziieren ein neues Objekt.

Können Sie sich auch ein Konstruktor mit ausgefallenen Argumenten am Ende.

Aber man kann nicht mehrere Konstruktoren, und rufen Sie dann jede von Ihnen separat.

InformationsquelleAutor der Antwort warren

Ich würde vorschlagen, die Verwendung eines private friend Methode, die implementiert die Anwendungslogik des Konstruktors und der sogenannte von den verschiedenen Konstruktoren. Hier ist ein Beispiel:

Angenommen, wir haben eine Klasse namens StreamArrayReader mit einige private Felder:

private:
    istream * in;
      //More private fields

Und wollen wir definieren zwei Konstruktoren:

public:
    StreamArrayReader(istream * in_stream);
    StreamArrayReader(char * filepath);
    //More constructors...

Wo der zweite macht einfach Gebrauch von der ersten (und wir natürlich nicht wollen, duplizieren Sie die Umsetzung der ehemaligen). Im Idealfall würde man etwas tun, wie:

StreamArrayReader::StreamArrayReader(istream * in_stream){
    //Implementation
}

StreamArrayReader::StreamArrayReader(char * filepath) {
    ifstream instream;
    instream.open(filepath);
    StreamArrayReader(&instream);
    instream.close();
}

Dies ist jedoch nicht erlaubt in C++. Aus diesem Grund können wir definieren ein eigenes Freund-Methode wie folgt implementiert, was der erste Konstruktor soll das tun:

private:
  friend void init_stream_array_reader(StreamArrayReader *o, istream * is);

Nun diese Methode (weil es ein Freund) hat Zugriff auf die privaten Felder o. Dann, der erste Konstruktor wird:

StreamArrayReader::StreamArrayReader(istream * is) {
    init_stream_array_reader(this, is);
}

Beachten Sie, dass diese nicht erstellen Sie mehrere Kopien für die neu erstellte kopiert. Der zweite wird:

StreamArrayReader::StreamArrayReader(char * filepath) {
    ifstream instream;
    instream.open(filepath);
    init_stream_array_reader(this, &instream);
    instream.close();
}

Ist, anstatt ein Konstruktor ruft einen anderen, beide nennen ein eigenes Freund!

InformationsquelleAutor der Antwort Pantelis Sopasakis

Beim Aufruf eines Konstruktors es tatsächlich Speicher reserviert, entweder aus dem stack oder auf dem heap. So ruft ein Konstruktor in einem anderen Konstruktor erzeugt eine lokale Kopie. So verändern wir ein anderes Objekt, nicht die, die wir fokussieren uns auf.

InformationsquelleAutor der Antwort XPD

Wäre einfacher zu testen, als zu entscheiden 🙂
Versuchen Sie dies:

#include <iostream>

class A {
public:
    A( int a) : m_a(a) {
        std::cout << "A::Ctor" << std::endl;    
    }
    ~A() {
        std::cout << "A::dtor" << std::endl;    
    }
public:
    int m_a;
};

class B : public A {
public:
    B( int a, int b) : m_b(b), A(a) {}
public:
    int m_b;
};

int main() {
    B b(9, 6);
    std::cout << "Test constructor delegation a = " << b.m_a << "; b = " << b.m_b << std::endl;    
    return 0;
}

und kompilieren Sie es mit 98 std:
g++ main.cpp -std=c++98 -o test_1

sehen Sie:

A::Ctor
Test constructor delegation a = 9; b = 6
A::dtor

so 🙂

InformationsquelleAutor der Antwort gyula