predeterminado d’tor virtual

Supongamos que tengo dos clases:

class Base{}; class Derived: public Base{}; 

ninguno tiene d’tor, en este caso si declaro sobre variables:

 Base b; Derived d; 

mi comstackdor producirá para mí d’tors, mi pregunta es, ¿los d’tors predeterminados de b and d serán virtuales o no?

Mi pregunta es, los d’tors de la b y d serán virtuales o no

No, no lo harán. Si desea un destructor virtual, tendrá que definir el suyo propio, incluso si su implementación es exactamente la misma que la que proporcionaría el comstackdor:

 class Base { public: virtual ~Base() {} }; 

Los destructores de Base y Derived no serán virtual . Para hacer un destructor virtual necesitas marcarlo explícitamente:

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

En realidad, ahora solo hay una razón para usar destructores virtuales. Eso es para cerrar la advertencia de gcc: “la clase ‘Base’ tiene funciones virtuales pero no destructor virtual”. Siempre que almacene sus objetos asignados en un shared_ptr , entonces realmente no necesita un destructor virtual. Así es cómo:

 #include  // cout, endl #include  // shared_ptr #include  // string struct Base { virtual std::string GetName() const = 0; }; class Concrete : public Base { std::string GetName() const { return "Concrete"; } }; int main() { std::shared_ptr b(new Concrete); std::cout << b->GetName() << std::endl; } 

El shared_ptr se limpiará correctamente, sin la necesidad de un destructor virtual. ¡Recuerda, tendrás que usar el shared_ptr !

¡Buena suerte!

Mi pregunta es, los d’tors de la b y d serán virtuales o no

Respuesta corta: Nopes!

NO serán virtuales. Sin embargo, si declara (y define) un dtor virtual en Base, el dtor derivado se volverá automáticamente virtual. HTH.

¿Cómo pueden ser virtuales a menos que explícitamente los conviertas como virtuales?

Solo para agregar un ejemplo más a la respuesta de Daniel Lidström

As long as you always store your allocated objects in a shared_ptr, then you really don't need a virtual destructor.

Si uno usa un shared_ptr como este:

  std::shared_ptr b(new Concrete); 

Luego, el destructor de hormigón y el destructor de base se llaman a la destrucción del objeto.

Si uno usa un shared_ptr como este:

 Base* pBase = new Concrete; std::shared_ptr b(pBase); 

Entonces solo se llama al destructor de Base en la destrucción del objeto.

Este es un ejemplo

 #include  // cout, endl #include  // shared_ptr #include  // string struct Base { virtual std::string GetName() const = 0; ~Base() { std::cout << "~Base\n"; } }; struct Concrete : public Base { std::string GetName() const { return "Concrete"; } ~Concrete() { std::cout << "~Concrete\n"; } }; int main() { { std::cout << "test 1\n"; std::shared_ptr b(new Concrete); std::cout << b->GetName() << std::endl; } { std::cout << "test 2\n"; Base* pBase = new Concrete; std::shared_ptr b(pBase); std::cout << b->GetName() << std::endl; } }