Wie rufe ich den Basisklassenkonstruktor auf?

latley ich verbrachte viel Programmierung in Java. Dort rufen Sie die Klasse, die Sie Geerbt von mit super(); (Sie alle wissen wahrscheinlich, dass)

Nun habe ich eine Klasse in C++ - das ist ein Standard-Konstruktor, nimmt einige Argumente. Beispiel:

class BaseClass {
public:
    BaseClass(char *name); ....

Wenn ich das Erben der Klasse gibt mir die Warnung, dass es kein geeigneter Standardkonstruktor verfügbar. Also gibt es so etwas wie super() in C++, oder muss ich eine Funktion definieren, wo ich die Initialisierung aller Variablen?

InformationsquelleAutor der Frage Stefan | 2011-08-03

c++constructor

71

Dass Sie dies in der Initialisierer-Liste der Konstruktor der Unterklasse.
```
class Foo : public BaseClass {
public:
    Foo() : BaseClass("asdf") {}
};
```
Basis-Klasse Konstruktoren, die Argumente zu nennen, bevor es an alle Mitglieder initialisiert werden.

InformationsquelleAutor der Antwort Björn Pollex
23

In der header-Datei definieren Sie eine Basis-Klasse:
```
class BaseClass {
public:
    BaseClass(params);
};
```
Definieren Sie dann eine abgeleitete Klasse, die als Erben der BaseClass:
```
class DerivedClass : public BaseClass {
public:
    DerivedClass(params);
};
```
In der Quelldatei definieren Sie die BaseClass Konstruktor:
```
BaseClass::BaseClass(params)
{
     //Perform BaseClass initialization
}
```
Standardmäßig wird der abgeleitete Konstruktor ruft nur die Standard-Basis-Konstruktor ohne Parameter; in diesem Beispiel wird die Basis-Klasse-Konstruktor wird NICHT automatisch aufgerufen, wenn der abgeleitete Konstruktor aufgerufen wird, aber es kann erreicht werden, indem Sie einfach die Basisklasse Konstruktor-syntax nach dem Doppelpunkt (:). Definieren einer abgeleiteten Konstruktor, der automatisch Anrufe seiner Basis-Konstruktor:
```
DerivedClass::DerivedClass(params) : BaseClass(params)
{
     //This occurs AFTER BaseClass(params) is called first and can
     //perform additional initialization for the derived class
}
```
Den BaseClass Konstruktor wird aufgerufen, BEVOR die DerivedClass Konstruktor, und gleiche/unterschiedliche Parameter params weitergeleitet werden, in dem der Basisklasse, falls gewünscht. Diese können verschachtelt werden, für tiefer abgeleiteten Klassen. Der abgeleitete Konstruktor aufrufen muss GENAU EINE Basis-Konstruktor. Die Destruktoren werden AUTOMATISCH aufgerufen, in der UMGEKEHRTEN Reihenfolge der Konstruktoren aufgerufen wurden.

EDIT: Es gibt eine Ausnahme von dieser Regel, wenn Sie sind die Erben von jedem virtual Klassen, in der Regel zu erreichen Mehrfachvererbung oder Diamant-Vererbung. Dann MÜSSEN Sie explizit aufrufen, die base-Konstruktoren aller virtual Basisklassen und übergeben Sie den Parameter explizit, sonst wird es nur aufrufen, Ihre Standard-Konstruktoren ohne alle Parameter. Siehe: virtuelle Vererbung - Konstruktoren überspringen

InformationsquelleAutor der Antwort MasterHD
17

Verwenden Sie initiailzers:
```
class DerivedClass : public BaseClass
{
public:
  DerivedClass()
    : BaseClass(<insert arguments here>)
  {
  }
};
```
Dies ist auch, wie erstellen Sie die Mitglieder Ihrer Klasse, die keine Konstruktoren (oder, die Sie initialisieren möchten). Alle Mitglieder, die nicht erwähnt werden default-initialisiert. Zum Beispiel:
```
class DerivedClass : public BaseClass
{
public:
  DerivedClass()
    : BaseClass(<insert arguments here>)
    , nc(<insert arguments here>)
    //di will be default initialized.
  {
  }

private:
  NeedsConstructor nc;
  CanBeDefaultInit di;
};
```
Die Bestellung der Mitglieder angegeben sind, ist irrelevant (obwohl die Konstruktoren müssen zuerst kommen), aber die Reihenfolge, in der Sie aufgebaut sein wird in der Reihenfolge der Deklaration. So nc wird immer gebaut werden, bevor di.

InformationsquelleAutor der Antwort Nicol Bolas
4

Bezüglich der alternative zu super; Sie würde in den meisten Fällen verwenden die Basisklasse entweder in der Initialisierungsliste der abgeleiteten Klasse, oder mit der Base::someData syntax, wenn du etwas woanders funktioniert, und die abgeleitete Klasse definiert Daten Mitglieder.
```
struct Base
{
    Base(char* name) { }
    virtual ~Base();
    int d;
};

struct Derived : Base
{
    Derived() : Base("someString") { }
    int d;
    void foo() { d = Base::d; }
};
```
InformationsquelleAutor der Antwort Schnommus
2

Gibt es kein super() in C++. Sie rufen die Basis-Konstruktor explizit mit Namen.

InformationsquelleAutor der Antwort Shamim Hafiz
2

Verwenden Sie den Namen der Basisklasse in einer Initialisierer-Liste. Der Initialisierer-Liste angezeigt, nachdem der Konstruktor Signatur vor die Methode Körper und kann verwendet werden, zu initialisieren, die Basis-Klassen und Mitglieder.
```
class Base
{
public:
  Base(char* name)
  {
     //...
  }
};

class Derived : Base
{
public:
  Derived()
    : Base("hello")
  {
      //...
  }
};
```
Oder ein Muster verwendet, die von einigen Leuten ist zu definieren, 'super' oder 'Basis' sich selbst. Vielleicht haben einige der Menschen, die zugunsten dieser Technik sind Java-Entwickler, die sich bewegen, um C++.
```
class Derived : Base
{
public:
  typedef Base super;
  Derived()
    : super("hello")
  {
      //...
  }
};
```
InformationsquelleAutor der Antwort Scott Langham

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.