c++ 虚析构函数

析构函数，在不需要类对象时，用于释放申请的资源，进行清理等。

1. 虚构函数在什么时候调用

  在类对象的内存结构被清理时，会自动调用析构函数。所以要知道何时析构函数被调用，只需要知道类对象内存何时被清理。

 （1） 临时对象，在类对象作用域外，系统会自动清理对象内存，析构函数也会自动被调用。

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int id):m_id(id)
	{
	}

	virtual ~fruit()
	{
		cout << "---- ~fruit() id:----" << m_id << endl;
	}
private:
	int m_id;
};

void fun()
{
	cout << "----fun begin----" << endl;
	fruit FRUIT(333);
	cout << "----fun end----" << endl;
}

int main(int argc, char **argv)
{
	cout << "----main begin----" << endl;
	fruit FRUIT_1(111);

	fun();

	{
		cout << "----{----" << endl;
		fruit FRUIT_2(222);
		cout << "----}----" << endl;
	}

	cout << "----main end----" << endl;
}

执行结果如下，可见对于临时对象，其生命期在于包围它的最内层的那一对大括号“{}”，在“}”之前，系统会清理此对象，调用类的析构函数。

 （2） new 出来的对象，其作用域不限于包围它的最内层大括号，系统不会主动清理。只有主动地调用 delete 清理对象内存，才会调用对象的析构函数。

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int id):m_id(id)
	{
	}

	virtual ~fruit()
	{
		cout << "---- ~fruit() id:----" << m_id << endl;
	}

private:
	int m_id;
};

int main(int argc, char **argv)
{
	fruit *FRUIT_1 = new fruit(111);
	fruit *FRUIT_2 = new fruit(222);

	delete FRUIT_1;
}

结果如下，可见由于主动调用delete FRUIT_1，析构函数才被调用。而 new fruit(222) 创建的对象，并没有自动析构函数。 

2. 继承体系下的析构函数调用。

（1）临时变量，析构时会顺序调用 自己的析构函数->基类的析构函数。

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int id):m_id(id)
	{
	}

	~fruit()
	{
		cout << "---- ~fruit() id:----" << m_id << endl;
	}

protected:
	int m_id;
};

class apple:public fruit
{
public:
	apple(int id):fruit(id)
	{
	}

	~apple()
	{
		cout << "---- ~apple()::fruit::id----" << fruit::m_id << endl;
	}
};

int main(int argc, char **argv)
{
	apple FRUIT_1(111);
}

执行结果如下

（2）new 出来的对象，并且析构函数不是虚函数。析构时，依据指针类型，清理相应的对象结构，调用相应的析构函数。

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int id):m_id(id)
	{
	}

	~fruit()
	{
		cout << "---- ~fruit() id:----" << m_id << endl;
	}

protected:
	int m_id;
};

class apple:public fruit
{
public:
	apple(int id):fruit(id)
	{
	}

	~apple()
	{
		cout << "---- ~apple()::fruit::id----" << fruit::m_id << endl;
	}
};

int main(int argc, char **argv)
{
	fruit *FRUIT_1 = new apple(111);
	apple *FRUIT_2 = new apple(222);

	delete FRUIT_1;
	delete FRUIT_2;
}

执行结果如下，可见 new apple(111) 生成的对象，由于其地址赋予了基类指针，delete 时，清理的是基类的内存对象，调用的是基类的析构函数。

（3）new 出来的对象，并且析构函数是虚函数。析构时，依据指针所指对象的实际类型，清理相应的对象结构，调用相应的析构函数。

#include <stdlib.h>
#include <iostream>

using namespace std;

class fruit
{
public:
	fruit(int id):m_id(id)
	{
	}

	~fruit()
	{
		cout << "---- ~fruit() id:----" << m_id << endl;
	}

protected:
	int m_id;
};

class apple:public fruit
{
public:
	apple(int id):fruit(id)
	{
	}

	~apple()
	{
		cout << "---- ~apple()::fruit::id----" << fruit::m_id << endl;
	}
};

int main(int argc, char **argv)
{
	fruit *FRUIT_1 = new apple(111);
	apple *FRUIT_2 = new apple(222);

	delete FRUIT_1;
	delete FRUIT_2;
}

执行结果如下，可见，无论指针式何种类型，delete 时，调用的总是 真实类型的析构函数。

3. 何时声明析构函数为虚函数？

   为了实现多态，可能会 new 出一个子类对象，将其赋值给基类指针，然后调用声明为虚函数的接口。 若不将析构函数声明为虚函数，在 delete 基类指针指向的对象时，可能不能正确地清理对象内存，调用正确的析构函数。

   通过上面的分析，所以如果基类中有虚函数接口，最好的做法是将析构函数声明为虚函数。