Was sind die Regeln für den Aufruf des Konstruktors der Basisklasse?

Question

Wie lauten die C++-Regeln für den Aufruf des Basisklassenkonstruktors aus einer abgeleiteten Klasse?

Ich weiß zum Beispiel, dass man das in Java in der ersten Zeile des Unterklassenkonstruktors tun muss (und wenn man das nicht tut, wird ein impliziter Aufruf eines Super-Konstruktors ohne Argumente angenommen, was zu einem Kompilierfehler führt, wenn das fehlt).

Answer 1

Die einzige Möglichkeit, Werte an einen übergeordneten Konstruktor zu übergeben, besteht in einer Initialisierungsliste. Die Initialisierungsliste wird mit einem : und einer Liste von Klassen und den Werten, die an den Konstruktor dieser Klasse übergeben werden sollen, implementiert.

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

Denken Sie auch daran, dass ein Konstruktor, der in der übergeordneten Klasse keine Parameter benötigt, automatisch aufgerufen wird, bevor der untergeordnete Konstruktor ausgeführt wird.

Answer 2

Wenn Sie Standardparameter in Ihrem Basiskonstruktor haben, wird die Basisklasse automatisch aufgerufen.

using namespace std;

class Base
{
    public:
    Base(int a=1) : _a(a) {}

    protected:
    int _a;
};

class Derived : public Base
{
  public:
  Derived() {}

  void printit() { cout << _a << endl; }
};

int main()
{
   Derived d;
   d.printit();
   return 0;
}

Ausgang ist: 1

Answer 3

CDerived::CDerived()
: CBase(...), iCount(0)  //this is the initialisation list. You can initialise member variables here too. (e.g. iCount := 0)
    {
    //construct body
    }

Answer 4

Niemand hat die Reihenfolge der Konstruktoraufrufe erwähnt, wenn eine Klasse von mehreren Klassen abgeleitet ist. Die Reihenfolge ist wie bei der Ableitung der Klassen angegeben.

Answer 5

Wenn Sie einfach nur alle Konstruktorargumente an die Basisklasse übergeben (=Eltern), hier ein minimales Beispiel.

Dabei werden Vorlagen verwendet, um jeden Konstruktoraufruf mit 1, 2 oder 3 Argumenten an die übergeordnete Klasse weiterzuleiten std::string .

Code

Live-Version

#include <iostream>
#include <string>

class ChildString: public std::string
{
    public:
        template<typename... Args>
        ChildString(Args... args): std::string(args...)
        {
            std::cout 
                << "\tConstructor call ChildString(nArgs="
                << sizeof...(Args) << "): " << *this
                << std::endl;
        }

};

int main()
{
    std::cout << "Check out:" << std::endl;
    std::cout << "\thttp://www.cplusplus.com/reference/string/string/string/" << std::endl;
    std::cout << "for available string constructors" << std::endl;

    std::cout << std::endl;
    std::cout << "Initialization:" << std::endl;
    ChildString cs1 ("copy (2)");

    char char_arr[] = "from c-string (4)";
    ChildString cs2 (char_arr);

    std::string str = "substring (3)";
    ChildString cs3 (str, 0, str.length());

    std::cout << std::endl;
    std::cout << "Usage:" << std::endl;
    std::cout << "\tcs1: " << cs1 << std::endl;
    std::cout << "\tcs2: " << cs2 << std::endl;
    std::cout << "\tcs3: " << cs3 << std::endl;

    return 0;
}

Ausgabe

Check out:
    http://www.cplusplus.com/reference/string/string/string/
for available string constructors

Initialization:
    Constructor call ChildString(nArgs=1): copy (2)
    Constructor call ChildString(nArgs=1): from c-string (4)
    Constructor call ChildString(nArgs=3): substring (3)

Usage:
    cs1: copy (2)
    cs2: from c-string (4)
    cs3: substring (3)

Update: Variadic-Vorlagen verwenden

Zur Verallgemeinerung auf n Argumente und zur Vereinfachung

        template <class C>
        ChildString(C arg): std::string(arg)
        {
            std::cout << "\tConstructor call ChildString(C arg): " << *this << std::endl;
        }
        template <class C1, class C2>
        ChildString(C1 arg1, C2 arg2): std::string(arg1, arg2)
        {
            std::cout << "\tConstructor call ChildString(C1 arg1, C2 arg2, C3 arg3): " << *this << std::endl;
        }
        template <class C1, class C2, class C3>
        ChildString(C1 arg1, C2 arg2, C3 arg3): std::string(arg1, arg2, arg3)
        {
            std::cout << "\tConstructor call ChildString(C1 arg1, C2 arg2, C3 arg3): " << *this << std::endl;
        }

zu

template<typename... Args>
        ChildString(Args... args): std::string(args...)
        {
            std::cout 
                << "\tConstructor call ChildString(nArgs="
                << sizeof...(Args) << "): " << *this
                << std::endl;
        }