当您希望不同的析构函数在通过基类指针删除对象时遵循正确的顺序时，析构函数的虚拟关键字是必需的。例如：

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

如果基类析构函数是虚拟的，那么对象将按顺序被析构函数（首先是派生对象，然后是基）。如果基类析构函数不是虚拟的，那么只有基类对象会被删除（因为指针是基类“base*myObj”）。因此派生对象将存在内存泄漏。

我认为这个问题的核心是关于虚拟方法和多态性，而不是具体的析构函数。下面是一个更清晰的例子：

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;
}

将打印出：

This is B.

如果没有虚拟，它将打印出：

This is A.

现在您应该了解何时使用虚拟析构函数。

我认为这里的大多数答案都没有抓住重点，除了公认的答案，这是一件好事。然而，让我再补充一个对这个问题有不同看法的问题：如果你想多态地删除这个类的实例，你需要一个虚拟析构函数。

这种方式回避了这个问题，所以让我详细说明一下：正如许多人所指出的，如果调用delete base_ptr并且析构函数不是虚拟的，就会出现不希望的行为。然而，有几个假设需要明确：

如果您的类不是基类，那么希望您不会编写这样的代码。在本例中，我不是指手动内存管理，它本身就很糟糕，而是从这个类中公开派生出来的。不应继承未设计为基类的类，例如std:：string。C++可以让你射自己的脚。这是你的错，而不是基类没有虚拟析构函数。如果析构函数不可访问（受保护的或私有的），则此代码不会编译，因此不会出现不希望的行为。有一个受保护的析构函数是有用的，特别是对于mixin，但对于接口（在较小程度上）也是有用的。除非您实际使用了虚拟函数，否则您不希望产生虚拟函数的开销。相反，使析构函数受到保护可以防止不期望的行为，但不会限制您的行为。如果您实际上编写了一个应该派生自的类，那么通常都会有虚拟函数。作为它们的用户，通常只能通过指向基类的指针来使用它们。当这种使用包括处理它们时，它也需要是多态的。当您应该将析构函数设为虚拟时，就会出现这种情况。

对于这个主题的一个类似的不同观点，也可以阅读“什么时候不应该使用虚拟析构函数？”？

什么是虚拟析构函数或如何使用虚拟析构器

类析构函数是一个与~前面的类同名的函数，它将重新分配该类分配的内存。为什么我们需要虚拟析构函数

请参见以下示例中的一些虚拟函数

该示例还说明了如何将字母转换为大写或小写

#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;
}

从上面的示例中可以看到，没有调用MakeUpper和MakeLower类的析构函数。

查看下一个带有虚拟析构函数的示例

#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;
}

虚拟析构函数将显式调用类的最派生的运行时析构函数，以便能够以正确的方式清除对象。

或访问链接

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

虚拟构造函数是不可能的，但虚拟析构函数是可能的。让我们做个实验。。。。。。。

#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;
}

上述代码输出以下内容：

Base Constructor Called
Derived constructor called
Base Destructor called

派生对象的构造遵循构造规则，但当我们删除“b”指针（基指针）时，我们发现只有基析构函数被调用。但这绝不能发生。为了做适当的事情，我们必须使基析构函数虚拟化。现在让我们看看以下情况：

#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;
}

输出变化如下：

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

因此，基指针的销毁（对派生对象进行分配！）遵循销毁规则，即首先是派生指针，然后是基指针。另一方面，没有什么像虚拟构造函数。

当您需要从基类调用派生类析构函数时。您需要在基类中声明虚拟基类析构函数。