Por que devo declarar um destruidor virtual para uma classe abstrata em C ++?

Sei que é uma boa prática declarar destruidores virtuais para classes base em C ++, mas é sempre importante declarar virtualdestruidores mesmo para classes abstratas que funcionam como interfaces? Forneça alguns motivos e exemplos do motivo.

É ainda mais importante para uma interface. Qualquer usuário da sua classe provavelmente conterá um ponteiro para a interface, não um ponteiro para a implementação concreta. Quando eles vierem para excluí-lo, se o destruidor não for virtual, eles chamarão o destruidor da interface (ou o padrão fornecido pelo compilador, se você não especificou um), não o destruidor da classe derivada. Vazamento de memória instantânea.

Por exemplo

class Interface
{
   virtual void doSomething() = 0;
};

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

void myFunc(void)
{
   Interface* p = new Derived();
   // The behaviour of the next line is undefined. It probably 
   // calls Interface::~Interface, not Derived::~Derived
   delete p; 
}

A resposta para sua pergunta é frequentemente, mas nem sempre. Se a sua classe abstrata proíbe que os clientes chamem delete em um ponteiro para ele (ou, se assim o desejar na documentação), você é livre para não declarar um destruidor virtual.

Você pode proibir que os clientes chamem delete em um ponteiro para ele, protegendo seu destruidor. Trabalhando assim, é perfeitamente seguro e razoável omitir um destruidor virtual.

Você acabará por não ter uma tabela de método virtual e sinalizará a seus clientes sua intenção de torná-la não excluída por meio de um ponteiro para ela, portanto, você tem motivos para não declara-la virtual nesses casos.

[Veja o item 4 deste artigo: http://www.gotw.ca/publications/mill18.htm ]

Decidi fazer uma pesquisa e tentar resumir suas respostas. As seguintes perguntas ajudarão você a decidir de que tipo de destruidor você precisa:

1. Sua classe deve ser usada como classe base?
   • Não: Declare o destruidor público não virtual para evitar o apontador v em cada objeto da classe ^* .
   • Sim: Leia a próxima pergunta.
2. Sua classe base é abstrata? (ou seja, algum método puro virtual?)
   • Não: tente tornar sua classe base abstrata redesenhando sua hierarquia de classes
   • Sim: Leia a próxima pergunta.
3. Deseja permitir a exclusão polimórfica através de um ponteiro de base?
   • Não: Declare o destruidor virtual protegido para impedir o uso indesejado.
   • Sim: declarar destruidor virtual público (sem sobrecarga neste caso).

Eu espero que isso ajude.

^* É importante observar que no C ++ não há como marcar uma classe como final (ou seja, não subclassável), portanto, caso decida declarar seu destruidor não virtual e público, lembre-se de alertar explicitamente seus colegas programadores contra derivado de sua classe.

Referências:

• "S. Meyers. C ++ mais eficaz, item 33 Addison-Wesley, 1996."
• Herb Sutter, Virtualidade, 2001
• C ++ Faq, 20.7, "Quando meu destruidor deve ser virtual?"
• As respostas para esta pergunta, é claro.

Sim, é sempre importante. Classes derivadas podem alocar memória ou manter referência a outros recursos que precisarão ser limpos quando o objeto for destruído. Se você não atribuir destruidores virtuais de suas interfaces / classes abstratas, toda vez que você excluir uma instância de classe derivada por meio de um identificador de classe base, o destruidor de sua classe derivada não será chamado.

Portanto, você está abrindo o potencial de vazamentos de memória

class IFoo
{
  public:
    virtual void DoFoo() = 0;
};

class Bar : public IFoo
{
  char* dooby = NULL;
  public:
    virtual void DoFoo() { dooby = new char[10]; }
    void ~Bar() { delete [] dooby; }
};

IFoo* baz = new Bar();
baz->DoFoo();
delete baz; // memory leak - dooby isn't deleted

Nem sempre é necessário, mas acho que é uma boa prática. O que ele faz é que ele permite que um objeto derivado seja excluído com segurança por meio de um ponteiro do tipo base.

Então, por exemplo:

Base *p = new Derived;
// use p as you see fit
delete p;

está mal formado se Basenão tiver um destruidor virtual, porque tentará excluir o objeto como se fosse um Base *.

Não é apenas uma boa prática. É a regra nº 1 para qualquer hierarquia de classes.

1. A classe mais básica de uma hierarquia em C ++ deve ter um destruidor virtual

Agora, o porquê. Tome a hierarquia animal típica. Os destruidores virtuais passam pelo despacho virtual, assim como qualquer outra chamada de método. Veja o exemplo a seguir.

Animal* pAnimal = GetAnimal();
delete pAnimal;

Suponha que Animal é uma classe abstrata. A única maneira pela qual o C ++ conhece o destruidor adequado a ser chamado é através do envio de método virtual. Se o destruidor não for virtual, ele simplesmente chamará o destruidor de Animal e não destruirá nenhum objeto nas classes derivadas.

A razão para tornar o destruidor virtual na classe base é que ele simplesmente remove a escolha das classes derivadas. Seu destruidor se torna virtual por padrão.

A resposta é simples: você precisa que ela seja virtual, caso contrário, a classe base não seria uma classe polimórfica completa.

    Base *ptr = new Derived();
    delete ptr; // Here the call order of destructors: first Derived then Base.

Você prefere a exclusão acima, mas se o destruidor da classe base não for virtual, apenas o destruidor da classe base será chamado e todos os dados na classe derivada permanecerão desmarcados.