EDIT: resumen de respuestas

En lo siguiente, B es una subclase de A.

Es una cuestión de terminología; los doctores y los dtors sonno heredado, en el sentido de que el ctor / dtor de B lo haráno ser prestado de la interfaz de A. Una clase tiene al menos un constructor y tiene exactamente un destructor.

Constructores:B no hereda constructores de A;A menos que el ctor de B llame explícitamenteuno de A ctor, el ctor predeterminado de A se llamará automáticamenteantes de El cuerpo de Ctor de B (la idea es que A debe inicializarse antes de que se cree B).Destructores:B no hereda el dtor de A;Después sale, el destructor de B llamará automáticamente al destructor de A.

Expresiones de gratitud: Me gustaría agradecer especialmente a Oli Charlesworth y Kos por sus respuestas, establecí la respuesta de Kos como la solución porque fue la que entendí mejor.

POSTE ORIGINAL

Cuando busca "sitio de herencia del destructor de C ++: stackoverflow.com" en Google, actualmente encuentra las siguientes publicaciones:

Herencia Constructor y Destructor: dos usuarios con una reputación de 30k + dicen que se heredó y que no¿Se heredan los destructores virtuales?: aquí no se menciona nada que apunte a que los destructores no sean heredados¿Destructores y herencia en C ++?: Los comentarios parecen indicar que los destructores son heredados.

Q1: Lo que también sé por la práctica es que no puede inicializar un objeto derivado con el mismo prototipo que su constructor principal sin definir explícitamente un constructor para la clase derivada, ¿es correcto?

A pesar de que es bastante claro a partir de las publicaciones que los destructores parecen ser heredados, todavía estoy desconcertado por el hecho de que un usuario con una reputación de 32k diría que no. Escribí un pequeño ejemplo que debería aclarar la 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();

}

y aquí está la salida (compilada con 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: ¿Alguien que piense que no es heredado, por favor explique eso?

Q3: Entonces, ¿qué sucede cuando se llama al constructor de una subclase con entradas? ¿Se llama también al "constructor vacío" de la superclase?