EDIT: Zusammenfassung der Antworten

Im Folgenden ist B eine Unterklasse von A.

Es ist eine Frage der Terminologie. ctors und dtors sindnicht geerbt in dem Sinne, dass der ctor / dtor von B wirdnicht von der Schnittstelle von A ausgeliehen werden. Eine Klasse hat mindestens einen Konstruktor und genau einen Destruktor.

Konstruktoren:B erbt keine Konstruktoren von A;Es sei denn, B's ctor ruft explizit aneiner von A's ctor, der voreingestellte ctor von A wird automatisch aufgerufenVor Ctor body von B (die Idee ist, dass A initialisiert werden muss, bevor B erstellt wird).Destruktoren:B erbt den dtor von A nicht;Nach dem Wenn er beendet wird, ruft der Destruktor von B automatisch den Destruktor von A auf.

Danksagung: Ich möchte insbesondere Oli Charlesworth und Kos für ihre Antworten danken. Ich habe die Antwort von Kos als die Lösung festgelegt, weil es die war, die ich am besten verstand.

ORIGINAL POST

Wenn Sie in Google nach "C ++ - Destruktorvererbungssite: stackoverflow.com" suchen, finden Sie derzeit die folgenden Beiträge:

Erbschaft von Konstruktoren und Destruktoren: Zwei Benutzer mit über 30.000 Reputationen geben an, dass es vererbt wurde und nichtWerden virtuelle Destruktoren vererbt?: hier wird nichts erwähnt, was darauf hindeuten würde, dass Destruktoren nicht vererbt werdenDestruktoren und Vererbung in C ++?: Die Kommentare scheinen darauf hinzudeuten, dass die Destruktoren geerbt wurden

Q1: Aus der Praxis weiß ich auch, dass Sie ein abgeleitetes Objekt nicht mit demselben Prototyp wie den übergeordneten Konstruktor initialisieren können, ohne explizit einen Konstruktor für die abgeleitete Klasse zu definieren. Ist das richtig?

Obwohl es aus den Posts ziemlich klar hervorgeht, dass Destruktoren geerbt zu sein scheinen, bin ich immer noch verwundert darüber, dass ein Benutzer mit 32k Reputation dies nicht sagen würde. Ich habe ein kleines Beispiel geschrieben, das die Meinung aller klarstellen soll:

#include <cstdio>

/******************************/

// Base class
struct A
{
    A() { printf( "\tInstance counter = %d (ctor)\n", ++instance_counter ); }
    ~A() { printf( "\tInstance counter = %d (dtor)\n", --instance_counter ); }

    static int instance_counter;
};

// Inherited class with default ctor/dtor
class B : public A {};

// Inherited class with defined ctor/dtor
struct C : public A
{
    C() { printf("\tC says hi!\n"); }
    ~C() { printf("\tC says bye!\n"); }
};

/******************************/

// Initialize counter
int A::instance_counter = 0;

/******************************/

// A few tests
int main()
{
    printf("Create A\n"); A a;
    printf("Delete A\n"); a.~A();

    printf("Create B\n"); B b;
    printf("Delete B\n"); b.~B();

    printf("Create new B stored as A*\n"); A *a_ptr = new B();
    printf("Delete previous pointer\n"); delete a_ptr;

    printf("Create C\n"); C c;
    printf("Delete C\n"); c.~C();

}

und hier ist die Ausgabe (kompiliert mit g ++ 4.4.3):

Create A
    Instance counter = 1 (ctor)
Delete A
    Instance counter = 0 (dtor)
Create B
    Instance counter = 1 (ctor)
Delete B
    Instance counter = 0 (dtor)
Create new B stored as A*
    Instance counter = 1 (ctor)
Delete previous pointer
    Instance counter = 0 (dtor)
Create C
    Instance counter = 1 (ctor)
    C says hi!
Delete C
    C says bye!
    Instance counter = 0 (dtor)  // We exit main() now
    C says bye! 
    Instance counter = -1 (dtor)
    Instance counter = -2 (dtor)
    Instance counter = -3 (dtor)

Q2: Kann jemand, der denkt, es sei nicht vererbt, das bitte erklären?

Q3: Was passiert also, wenn Sie den Konstruktor einer Unterklasse mit Eingaben aufrufen? Wird auch der "leere Konstruktor" der Oberklasse aufgerufen?