¿Cuándo usar destructores virtuales?

Tengo una sólida comprensión de la mayoría de la teoría OO, pero lo único que me confunde mucho son los destructores virtuales.

Pensé que el destructor siempre se llama sin importar qué y para cada objeto en la cadena.

¿Cuándo debes hacerlos virtuales y por qué?

Los destructores virtuales son útiles cuando podría eliminar una instancia de una clase derivada a través de un puntero a la clase base:

class Base 
{
    // some virtual methods
};

class Derived : public Base
{
    ~Derived()
    {
        // Do some important cleanup
    }
};

Aquí, notará que no he declarado que el destructor de Base sea virtual. Ahora, echemos un vistazo al siguiente fragmento:

Base *b = new Derived();
// use b
delete b; // Here's the problem!

Desde destructor de base no está virtualy bes un Base*apuntador a un Derivedobjeto, delete btiene un comportamiento indefinido :

[En delete b], si el tipo estático del objeto a eliminar es diferente de su tipo dinámico, el tipo estático será una clase base del tipo dinámico del objeto a eliminar y el tipo estático tendrá un destructor virtual o El comportamiento es indefinido .

En la mayoría de las implementaciones, la llamada al destructor se resolverá como cualquier código no virtual, lo que significa que se llamará al destructor de la clase base pero no al de la clase derivada, lo que provocará una pérdida de recursos.

En resumen, siempre haga los destructores de las clases base virtualcuando estén destinados a ser manipulados polimórficamente.

Si desea evitar la eliminación de una instancia a través de un puntero de clase base, puede hacer que el destructor de clase base esté protegido y no sea virtual; Al hacerlo, el compilador no le permitirá llamar deletea un puntero de clase base.

Puede obtener más información sobre virtualidad y destructor de clase base virtual en este artículo de Herb Sutter .

Un constructor virtual no es posible pero sí es posible un destructor virtual. Experimentemos .......

#include <iostream>

using namespace std;

class Base
{
public:
    Base(){
        cout << "Base Constructor Called\n";
    }
    ~Base(){
        cout << "Base Destructor called\n";
    }
};

class Derived1: public Base
{
public:
    Derived1(){
        cout << "Derived constructor called\n";
    }
    ~Derived1(){
        cout << "Derived destructor called\n";
    }
};

int main()
{
    Base *b = new Derived1();
    delete b;
}

El código anterior genera lo siguiente:

Base Constructor Called
Derived constructor called
Base Destructor called

La construcción del objeto derivado sigue la regla de construcción pero cuando eliminamos el puntero "b" (puntero base) hemos encontrado que solo se llama al destructor base. Pero esto no debe suceder. Para hacer lo apropiado, tenemos que hacer que el destructor base sea virtual. Ahora veamos qué sucede en lo siguiente:

#include <iostream>

using namespace std;

class Base
{ 
public:
    Base(){
        cout << "Base Constructor Called\n";
    }
    virtual ~Base(){
        cout << "Base Destructor called\n";
    }
};

class Derived1: public Base
{
public:
    Derived1(){
        cout << "Derived constructor called\n";
    }
    ~Derived1(){
        cout << "Derived destructor called\n";
    }
};

int main()
{
    Base *b = new Derived1();
    delete b;
}

La salida cambió de la siguiente manera:

Base Constructor Called
Derived Constructor called
Derived destructor called
Base destructor called

Entonces, la destrucción del puntero base (¡que toma una asignación en un objeto derivado!) Sigue la regla de destrucción, es decir, primero el Derivado, luego la Base. Por otro lado, no hay nada como un constructor virtual.

Declarar destructores virtuales en clases base polimórficas. Este es el ítem 7 en C ++ eficaz de Scott Meyers . Meyers continúa resumiendo que si una clase tiene alguna función virtual, debería tener un destructor virtual, y que las clases no diseñadas para ser clases base o no diseñadas para usarse polimórficamente no deberían declarar destructores virtuales.

También tenga en cuenta que eliminar un puntero de clase base cuando no hay un destructor virtual dará como resultado un comportamiento indefinido . Algo que aprendí recientemente:

¿Cómo debe comportarse la eliminación de eliminar en C ++?

He estado usando C ++ durante años y todavía me las arreglo para ahorcarme.

Haga que el destructor sea virtual siempre que su clase sea polimórfica.

Llamar a destructor mediante un puntero a una clase base

struct Base {
  virtual void f() {}
  virtual ~Base() {}
};

struct Derived : Base {
  void f() override {}
  ~Derived() override {}
};

Base* base = new Derived;
base->f(); // calls Derived::f
base->~Base(); // calls Derived::~Derived

La llamada de destructor virtual no es diferente de cualquier otra llamada de función virtual.

Para base->f(), la llamada se enviará a Derived::f(), y es lo mismo para base->~Base()su función de anulación Derived::~Derived(), se llamará.

Lo mismo sucede cuando se llama al destructor indirectamente, por ejemplo delete base;. La deletedeclaración llamará base->~Base()y se enviará aDerived::~Derived() .

Clase abstracta con destructor no virtual

Si no va a eliminar un objeto a través de un puntero a su clase base, entonces no es necesario tener un destructor virtual. Solo hazlo protectedpara que no se llame accidentalmente:

// library.hpp

struct Base {
  virtual void f() = 0;

protected:
  ~Base() = default;
};

void CallsF(Base& base);
// CallsF is not going to own "base" (i.e. call "delete &base;").
// It will only call Base::f() so it doesn't need to access Base::~Base.

//-------------------
// application.cpp

struct Derived : Base {
  void f() override { ... }
};

int main() {
  Derived derived;
  CallsF(derived);
  // No need for virtual destructor here as well.
}

Me gusta pensar en interfaces e implementaciones de interfaces. En C ++, la interfaz de hablar es pura clase virtual. Destructor es parte de la interfaz y se espera que se implemente. Por lo tanto, destructor debe ser puramente virtual. ¿Qué tal constructor? El constructor en realidad no es parte de la interfaz porque el objeto siempre se instancia explícitamente.

La palabra clave virtual para destructor es necesaria cuando desea que diferentes destructores sigan el orden correcto mientras los objetos se eliminan a través del puntero de clase base. por ejemplo:

Base *myObj = new Derived();
// Some code which is using myObj object
myObj->fun();
//Now delete the object
delete myObj ; 

Si el destructor de la clase base es virtual, los objetos se destruirán en un orden (primero el objeto derivado y luego la base). Si el destructor de la clase base NO es virtual, solo se eliminará el objeto de la clase base (porque el puntero es de la clase base "Base * myObj"). Entonces habrá pérdida de memoria para el objeto derivado.

Para ser simple, el destructor virtual es destruir los recursos en un orden adecuado, cuando elimina un puntero de clase base que apunta a un objeto de clase derivado.

 #include<iostream>
 using namespace std;
 class B{
    public:
       B(){
          cout<<"B()\n";
       }
       virtual ~B(){ 
          cout<<"~B()\n";
       }
 };
 class D: public B{
    public:
       D(){
          cout<<"D()\n";
       }
       ~D(){
          cout<<"~D()\n";
       }
 };
 int main(){
    B *b = new D();
    delete b;
    return 0;
 }

OUTPUT:
B()
D()
~D()
~B()

==============
If you don't give ~B()  as virtual. then output would be 
B()
D()
~B()
where destruction of ~D() is not done which leads to leak

Los destructores de clase base virtuales son la "mejor práctica": siempre debe usarlos para evitar pérdidas de memoria (difíciles de detectar). Al usarlos, puede estar seguro de que todos los destructores en la cadena de herencia de sus clases están siendo llamados (en el orden correcto). La herencia de una clase base que usa el destructor virtual hace que el destructor de la clase heredada también sea automáticamente virtual (por lo que no tiene que volver a escribir 'virtual' en la declaración del destructor de la clase heredadora).

Si usa shared_ptr(solo shared_ptr, no unique_ptr), no tiene que tener el destructor de clase base virtual:

#include <iostream>
#include <memory>

using namespace std;

class Base
{
public:
    Base(){
        cout << "Base Constructor Called\n";
    }
    ~Base(){ // not virtual
        cout << "Base Destructor called\n";
    }
};

class Derived: public Base
{
public:
    Derived(){
        cout << "Derived constructor called\n";
    }
    ~Derived(){
        cout << "Derived destructor called\n";
    }
};

int main()
{
    shared_ptr<Base> b(new Derived());
}

salida:

Base Constructor Called
Derived constructor called
Derived destructor called
Base Destructor called

¿Qué es un destructor virtual o cómo usar un destructor virtual?

Un destructor de clase es una función con el mismo nombre de la clase que precede a ~ que reasignará la memoria asignada por la clase. ¿Por qué necesitamos un destructor virtual?

Vea el siguiente ejemplo con algunas funciones virtuales

La muestra también le dice cómo puede convertir una letra en mayúscula o minúscula

#include "stdafx.h"
#include<iostream>
using namespace std;
// program to convert the lower to upper orlower
class convertch
{
public:
  //void convertch(){};
  virtual char* convertChar() = 0;
  ~convertch(){};
};

class MakeLower :public convertch
{
public:
  MakeLower(char *passLetter)
  {
    tolower = true;
    Letter = new char[30];
    strcpy(Letter, passLetter);
  }

  virtual ~MakeLower()
  {
    cout<< "called ~MakeLower()"<<"\n";
    delete[] Letter;
  }

  char* convertChar()
  {
    size_t len = strlen(Letter);
    for(int i= 0;i<len;i++)
      Letter[i] = Letter[i] + 32;
    return Letter;
  }

private:
  char *Letter;
  bool tolower;
};

class MakeUpper : public convertch
{
public:
  MakeUpper(char *passLetter)
  {
    Letter = new char[30];
    toupper = true;
    strcpy(Letter, passLetter);
  }

  char* convertChar()
  {   
    size_t len = strlen(Letter);
    for(int i= 0;i<len;i++)
      Letter[i] = Letter[i] - 32;
    return Letter;
  }

  virtual ~MakeUpper()
  {
    cout<< "called ~MakeUpper()"<<"\n";
    delete Letter;
  }

private:
  char *Letter;
  bool toupper;
};


int _tmain(int argc, _TCHAR* argv[])
{
  convertch *makeupper = new MakeUpper("hai"); 
  cout<< "Eneterd : hai = " <<makeupper->convertChar()<<" ";     
  delete makeupper;
  convertch *makelower = new MakeLower("HAI");;
  cout<<"Eneterd : HAI = " <<makelower->convertChar()<<" "; 
  delete makelower;
  return 0;
}

En el ejemplo anterior, puede ver que no se llama al destructor de las clases MakeUpper y MakeLower.

Vea la siguiente muestra con el destructor virtual

#include "stdafx.h"
#include<iostream>

using namespace std;
// program to convert the lower to upper orlower
class convertch
{
public:
//void convertch(){};
virtual char* convertChar() = 0;
virtual ~convertch(){}; // defined the virtual destructor

};
class MakeLower :public convertch
{
public:
MakeLower(char *passLetter)
{
tolower = true;
Letter = new char[30];
strcpy(Letter, passLetter);
}
virtual ~MakeLower()
{
cout<< "called ~MakeLower()"<<"\n";
      delete[] Letter;
}
char* convertChar()
{
size_t len = strlen(Letter);
for(int i= 0;i<len;i++)
{
Letter[i] = Letter[i] + 32;

}

return Letter;
}

private:
char *Letter;
bool tolower;

};
class MakeUpper : public convertch
{
public:
MakeUpper(char *passLetter)
{
Letter = new char[30];
toupper = true;
strcpy(Letter, passLetter);
}
char* convertChar()
{

size_t len = strlen(Letter);
for(int i= 0;i<len;i++)
{
Letter[i] = Letter[i] - 32;
}
return Letter;
}
virtual ~MakeUpper()
{
      cout<< "called ~MakeUpper()"<<"\n";
delete Letter;
}
private:
char *Letter;
bool toupper;
};


int _tmain(int argc, _TCHAR* argv[])
{

convertch *makeupper = new MakeUpper("hai");

cout<< "Eneterd : hai = " <<makeupper->convertChar()<<" \n";

delete makeupper;
convertch *makelower = new MakeLower("HAI");;
cout<<"Eneterd : HAI = " <<makelower->convertChar()<<"\n ";


delete makelower;
return 0;
}

El destructor virtual llamará explícitamente al destructor de tiempo de ejecución más derivado de la clase para que pueda borrar el objeto de manera adecuada.

O visita el enlace

https://web.archive.org/web/20130822173509/http://www.programminggallery.com/article_details.php?article_id=138

cuando necesita llamar al destructor de clase derivada de la clase base. necesita declarar el destructor virtual de la clase base en la clase base.

Creo que el núcleo de esta pregunta es sobre métodos virtuales y polimorfismo, no el destructor específicamente. Aquí hay un ejemplo más claro:

class A
{
public:
    A() {}
    virtual void foo()
    {
        cout << "This is A." << endl;
    }
};

class B : public A
{
public:
    B() {}
    void foo()
    {
        cout << "This is B." << endl;
    }
};

int main(int argc, char* argv[])
{
    A *a = new B();
    a->foo();
    if(a != NULL)
    delete a;
    return 0;
}

Imprimirá:

This is B.

Sin virtualella se imprimirá:

This is A.

Y ahora debes entender cuándo usar destructores virtuales.

Pensé que sería beneficioso discutir el comportamiento "indefinido", o al menos el comportamiento indefinido "bloqueado" que puede ocurrir al eliminar a través de una clase base (/ struct) sin un destructor virtual, o más precisamente, no hay vtable. El siguiente código enumera algunas estructuras simples (lo mismo sería cierto para las clases).

#include <iostream>
using namespace std;

struct a
{
    ~a() {}

    unsigned long long i;
};

struct b : a
{
    ~b() {}

    unsigned long long j;
};

struct c : b
{
    ~c() {}

    virtual void m3() {}

    unsigned long long k;
};

struct d : c
{
    ~d() {}

    virtual void m4() {}

    unsigned long long l;
};

int main()
{
    cout << "sizeof(a): " << sizeof(a) << endl;
    cout << "sizeof(b): " << sizeof(b) << endl;
    cout << "sizeof(c): " << sizeof(c) << endl;
    cout << "sizeof(d): " << sizeof(d) << endl;

    // No issue.

    a* a1 = new a();
    cout << "a1: " << a1 << endl;
    delete a1;

    // No issue.

    b* b1 = new b();
    cout << "b1: " << b1 << endl;
    cout << "(a*) b1: " << (a*) b1 << endl;
    delete b1;

    // No issue.

    c* c1 = new c();
    cout << "c1: " << c1 << endl;
    cout << "(b*) c1: " << (b*) c1 << endl;
    cout << "(a*) c1: " << (a*) c1 << endl;
    delete c1;

    // No issue.

    d* d1 = new d();
    cout << "d1: " << d1 << endl;
    cout << "(c*) d1: " << (c*) d1 << endl;
    cout << "(b*) d1: " << (b*) d1 << endl;
    cout << "(a*) d1: " << (a*) d1 << endl;
    delete d1;

    // Doesn't crash, but may not produce the results you want.

    c1 = (c*) new d();
    delete c1;

    // Crashes due to passing an invalid address to the method which
    // frees the memory.

    d1 = new d();
    b1 = (b*) d1;
    cout << "d1: " << d1 << endl;
    cout << "b1: " << b1 << endl;
    delete b1;  

/*

    // This is similar to what's happening above in the "crash" case.

    char* buf = new char[32];
    cout << "buf: " << (void*) buf << endl;
    buf += 8;
    cout << "buf after adding 8: " << (void*) buf << endl;
    delete buf;
*/
}

No estoy sugiriendo si necesita destructores virtuales o no, aunque creo que en general es una buena práctica tenerlos. Solo estoy señalando la razón por la que puede terminar con un bloqueo si su clase base (/ struct) no tiene una tabla vtable y su clase derivada (/ struct) sí y elimina un objeto a través de una clase base (/ struct) puntero. En este caso, la dirección que pasa a la rutina gratuita del montón no es válida y, por lo tanto, la razón del bloqueo.

Si ejecuta el código anterior, verá claramente cuándo se produce el problema. Cuando el puntero this de la clase base (/ struct) es diferente del puntero this de la clase derivada (/ struct), se encontrará con este problema. En el ejemplo anterior, las estructuras ayb no tienen vtables. Las estructuras cyd tienen vtables. Por lo tanto, un puntero aob para una instancia de objeto ac o d se corregirá para dar cuenta de la tabla vtable. Si pasa este puntero aob para eliminarlo, se bloqueará debido a que la dirección no es válida para la rutina libre del montón.

Si planea eliminar instancias derivadas que tienen vtables de punteros de clase base, debe asegurarse de que la clase base tenga una vtable. Una forma de hacerlo es agregar un destructor virtual, que de todos modos es posible que desee limpiar adecuadamente los recursos.

Una definición básica sobre virtuales si determina si una función miembro de una clase puede ser anulada en sus clases derivadas.

El D-tor de una clase se llama básicamente al final del alcance, pero hay un problema, por ejemplo, cuando definimos una instancia en el montón (asignación dinámica), deberíamos eliminarla manualmente.

Tan pronto como se ejecuta la instrucción, se llama al destructor de clase base, pero no para el derivado.

Un ejemplo práctico es cuando, en el campo de control, tienes que manipular efectores, actuadores.

Al final del alcance, si no se llama al destructor de uno de los elementos de poder (Actuador), habrá consecuencias fatales.

#include <iostream>

class Mother{

public:

    Mother(){

          std::cout<<"Mother Ctor"<<std::endl;
    }

    virtual~Mother(){

        std::cout<<"Mother D-tor"<<std::endl;
    }


};

class Child: public Mother{

    public:

    Child(){

        std::cout<<"Child C-tor"<<std::endl;
    }

    ~Child(){

         std::cout<<"Child D-tor"<<std::endl;
    }
};

int main()
{

    Mother *c = new Child();
    delete c;

    return 0;
}

Cualquier clase que se herede públicamente, polimórfica o no, debe tener un destructor virtual. En otras palabras, si un puntero de clase base puede señalarlo, su clase base debería tener un destructor virtual.

Si es virtual, se llama al destructor de la clase derivada, luego al constructor de la clase base. Si no es virtual, solo se llama al destructor de la clase base.