我对大多数OOP理论都有很好的理解，但最让我困惑的是虚拟析构函数。
我以为析构函数总是被调用，不管是什么，也不管是链中的每个对象。
你打算什么时候让它们虚拟化？为什么？
当前回答
简单地说，当您删除指向派生类对象的基类指针时，虚拟析构函数将以正确的顺序析构函数资源。
#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
其他回答
当您希望不同的析构函数在通过基类指针删除对象时遵循正确的顺序时，析构函数的虚拟关键字是必需的。例如：
Base *myObj = new Derived();
// Some code which is using myObj object
myObj->fun();
//Now delete the object
delete myObj ;
如果基类析构函数是虚拟的，那么对象将按顺序被析构函数（首先是派生对象，然后是基）。如果基类析构函数不是虚拟的，那么只有基类对象会被删除（因为指针是基类“base*myObj”）。因此派生对象将存在内存泄漏。
什么是虚拟析构函数或如何使用虚拟析构器
类析构函数是一个与~前面的类同名的函数，它将重新分配该类分配的内存。为什么我们需要虚拟析构函数
请参见以下示例中的一些虚拟函数
该示例还说明了如何将字母转换为大写或小写
#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
我认为这里的大多数答案都没有抓住重点，除了公认的答案，这是一件好事。然而，让我再补充一个对这个问题有不同看法的问题：如果你想多态地删除这个类的实例，你需要一个虚拟析构函数。
这种方式回避了这个问题，所以让我详细说明一下：正如许多人所指出的，如果调用delete base_ptr并且析构函数不是虚拟的，就会出现不希望的行为。然而，有几个假设需要明确：
如果您的类不是基类，那么希望您不会编写这样的代码。在本例中，我不是指手动内存管理，它本身就很糟糕，而是从这个类中公开派生出来的。不应继承未设计为基类的类，例如std:：string。C++可以让你射自己的脚。这是你的错，而不是基类没有虚拟析构函数。如果析构函数不可访问（受保护的或私有的），则此代码不会编译，因此不会出现不希望的行为。有一个受保护的析构函数是有用的，特别是对于mixin，但对于接口（在较小程度上）也是有用的。除非您实际使用了虚拟函数，否则您不希望产生虚拟函数的开销。相反，使析构函数受到保护可以防止不期望的行为，但不会限制您的行为。如果您实际上编写了一个应该派生自的类，那么通常都会有虚拟函数。作为它们的用户，通常只能通过指向基类的指针来使用它们。当这种使用包括处理它们时，它也需要是多态的。当您应该将析构函数设为虚拟时，就会出现这种情况。
对于这个主题的一个类似的不同观点，也可以阅读“什么时候不应该使用虚拟析构函数？”？
将所有析构函数都设为虚拟，除非你有充分的理由不这样做。
否则会发生这样的邪恶：
假设您有一个包含Apple和Orange对象的Fruit指针数组。
从Fruit对象集合中删除时，除非~Fruit（）是虚拟的，否则无法调用~Apple（）和~Orange（）。
正确完成示例：
#include <iostream>
using namespace std;
struct Fruit { // good
virtual ~Fruit() { cout << "peel or core should have been tossed" << endl; }
};
struct Apple: Fruit { virtual ~Apple() {cout << "toss core" << endl; } };
struct Orange: Fruit { virtual ~Orange() {cout << "toss peel" << endl; } };
int main() {
Fruit *basket[]={ new Apple(), new Orange() };
for (auto fruit: basket) delete fruit;
};
正品产出量
toss core
peel or core should have been tossed
toss peel
peel or core should have been tossed
错误示例：
#include <iostream>
using namespace std;
struct Fruit { // bad
~Fruit() { cout << "peel or core should have been tossed" << endl; }
};
struct Apple: Fruit { virtual ~Apple() {cout << "toss core" << endl; } };
struct Orange: Fruit { virtual ~Orange() {cout << "toss peel" << endl; } };
int main() {
Fruit *basket[]={ new Apple(), new Orange() };
for (auto fruit: basket) delete fruit;
};
不良输出
peel or core should have been tossed
peel or core should have been tossed
（注意：为了简洁起见，我使用了struct，通常使用class并指定public）
只要类是多态的，就将析构函数设为虚拟。
