EDIT: Resumo das respostas

A seguir, B é uma subclasse de A.

É uma questão de terminologia; ctors e dtors sãonão herdada, no sentido de que o coordenador / dtor de Bnão ser emprestado da interface do A. Uma classe tem pelo menos um construtor e tem exatamente um destruidor.

Construtores:B não herda construtores de A;A menos que o coordenador de B chame explicitamenteum de O ctor de A, o ctor padrão de A, será chamado automaticamenteantes O corpo de B (a ideia é que A precisa ser inicializado antes de B ser criado).Destruidores:B não herda o dtor de A;Depois de Se ele sair, o destruidor de B chamará automaticamente o destruidor de A.

Agradecimentos: Eu gostaria de agradecer especialmente a Oli Charlesworth e Kos por suas respostas, eu defini a resposta de Kos como a solução porque foi a que eu entendi melhor.

POSTE ORIGINAL

Quando você procura por "site de herança de destruição de C ++: stackoverflow.com" no Google, você encontra atualmente as seguintes postagens:

Herança de Construtor e Destructor: dois usuários com 30k + reputação dizem que é herdado e que não éOs destruidores virtuais são herdados?: aqui nada é mencionado que apontaria para os destruidores não serem herdadosDestrutores e herança em C ++?: Os comentários parecem indicar que os destruidores são herdados

Q1: O que também sei da prática é que você não pode inicializar um objeto derivado com o mesmo protótipo do que seu construtor pai sem definir explicitamente um construtor para a classe derivada, correto?

Mesmo que seja bastante claro a partir dos posts que os destrutores parecem ser herdados, eu ainda estou intrigado com o fato de que um usuário com reputação de 32k diria que não. Eu escrevi um pequeno exemplo que deveria esclarecer a mente de todos:

#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();

}

e aqui está a saída (compilada com 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: Alguém que acha que não é herdado, por favor explique isso?

Q3: Então, o que acontece quando você chama o construtor de uma subclasse com entradas? O "construtor vazio" da superclasse também é chamado?