C++——什么时候析构函数需要写成虚函数

作者：小 琛
欢迎转载，请标明出处

引言：什么情况下析构函数最好定义为虚函数？为什么？

答：在实现多态时。
在实现多态时，当一个类被作为基类并且该基类对派生类的对象进行操作，在析构时防止只析构基类而不析构派生类的状况发生。把基类的析构函数设计为虚函数可以在基类的指针指向派生类对象时，用基类的指针删除派生类对象，避免内存泄漏。

举例分析

#include <iostream>
class A
{
public:
	~A()
	{
		std::cout << "delete A" << std::endl;
	}

	virtual void print()
	{
		std::cout << "print A" << std::endl;
	}
};
class B : public A
{
public:
	~B()
	{
		std::cout << "delete B" << std::endl;

	}
	virtual void print()
	{
		std::cout << "print B" << std::endl;
	}
};
void function(A& v)
{
	v.print();
}
int main()
{
	B* temp = new B;
	temp->print();
	delete temp;
	return 0;
}

结果展示：

这段代码中基类的析构函数不是虚函数，在main函数中用继承类B的指针去操作继承类B的成员，释放指针P的过程是：先释放继承类的资源，再释放基类资源，不存在问题

但是看如下情况：

#include <iostream>
class A
{
public:
	~A()
	{
		std::cout << "delete A" << std::endl;
	}

	virtual void print()
	{
		std::cout << "print A" << std::endl;
	}
};
class B : public A
{
public:
	~B()
	{
		std::cout << "delete B" << std::endl;

	}
	virtual void print()
	{
		std::cout << "print B" << std::endl;
	}
};
void function(A& v)
{
	v.print();
}
int main()
{
	A* temp = new B;//用基类的指针去操作继承类B
	temp->print();
	delete temp;
	return 0;
}

结果如下：

可以看到，仅仅析构了基类而派生类并没有完成析构。 一般情况下，这样的删除只能够删除基类对象，而不能删除派生类对象，形成了删除一半形象，造成内存泄漏。

在公有继承中，基类对派生类及其对象的操作，只能影响到那些从基类继承下来的成员。 如果想要用基类对非继承成员进行操作，则要把基类的这个函数定义为虚函数。
析构函数自然也应该如此：如果它想析构子类中的重新定义或新的成员及对象，当然也应该把函数定义为虚函数。

代码修改如下：

#include <iostream>
class A
{
public:
	virtual ~A()
	{
		std::cout << "delete A" << std::endl;
	}

	virtual void print()
	{
		std::cout << "print A" << std::endl;
	}
};
class B : public A
{
public:
	virtual ~B()
	{
		std::cout << "delete B" << std::endl;

	}
	virtual void print()
	{
		std::cout << "print B" << std::endl;
	}
};
void function(A& v)
{
	v.print();
}
int main()
{
	A* temp = new B;
	temp->print();
	delete temp;
	return 0;
}

结果如下：

代码中基类的析构函数被定义为虚函数，在main函数中用基类的指针去操作继承类的成员，释放指针P的过程是：先释放了继承类的资源，再调用基类的析构函数。

注意：
如果不需要基类对派生类及对象进行操作，则不必要定义虚函数。 因为这样会增加内存开销。当类里面有定义虚函数的时候，编译器会给类添加一个虚函数表，里面来存放虚函数指针，这样就会增加类的存储空间。