多态时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码，则导致内存泄漏。
解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
1，可以解决父类指针释放子类对象
2，都需要有具体的函数实现
虚析构和纯虚析构区别：
如果时纯虚析构，则该类属于抽象类，无法实例化对象
虚析构语法：
virtual ~类名() { … }
纯虚析构语法：
virtual ~类名() = 0;
类名:: ~类名() { …}

#include <iostream>
#include <string>
using namespace std;

class Animal
{
public:
	//只要有一个纯虚函数，这个函数称为抽象类
	//抽象类特点：1、无法实例化对象		2、抽象类的子类必须要重写父类的纯虚函数
	Animal()
	{
		cout << "Animal构造函数调用" << endl;
	}
	//使用虚析构可以解决 父类指针释放子类对象时不干净的问题
	virtual ~Animal()
	{
		cout << "Animal虚析构函数调用" << endl;
	}

	//纯虚析构函数  1、需要声明也需要实现  2、有了纯虚析构之后，这个类也属于抽象类，无法实例化
//	virtual ~Animal() = 0;
	virtual void speak() = 0;  //纯虚函数
};
//Animal::~Animal()
//{
//	cout << "Animal纯虚析构函数调用" << endl;
//}

class Cat : public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);     //开辟到堆区
	}

	~Cat()
	{
		if (m_Name != NULL)
		{
			cout << "Cat析构函数调用" << endl;
		//	m_Name = NULL;
			delete m_Name;
		}
	}

	virtual void speak()
	{
		cout << *m_Name << "小猫在说话" << endl;
	}

	string *m_Name;  //开辟到堆区
};

void test01()
{
	
	Animal *animal = new Cat("Tom");
	animal->speak();
	delete animal;
}

int main()
{

	test01();
	system("pause");
	return 0;
}

虚析构函数和纯虚析构函数

如果有一定基础的伙伴来看这篇文章之前应该都知道虚析构函数的用途，虚析构函数就是防止有有没有释放干净的内存，防止内存泄漏。

没学过也没有关系我们通过了解原理的过程来学习这个虚析构和纯虚析构函数。

首先字面意思，分开理解，先看虚析构函数，析构函数就是释放内存的东西，虚函数，第六章我们都没离开这个东西，所以我们可以和虚表联系起来。那就是有虚表的析构函数吧。（纯虚析构函数我们最后再讲）

通过画图来理解我们的整个过程。（最近发现画图是真好用，形象）

最开始我们来探究我们没有虚析构函数的代码，然后再来对比有虚函数的代码，对比了才明显

先贴上我们要的没有虚析构函数刨析的代码：

#include<iostream>
using namespace std;
class A
{
public:
	A()
	{
		cout << "A中构造函数的调用" << endl;
		p_A = new int(666);
	}
	~A()
	{
		if (p_A != NULL)
		{
			cout << "A中析构函数的调用" << endl;
			delete(p_A);
			p_A = NULL;
		}
	}
	int* p_A;
};
class B:public A
{
public:
	B()
	{
		cout << "B中构造函数的调用" << endl;
		p_B = new int(999);
	}
	~B()
	{
		if (p_B != NULL)
		{
			cout << "B中析构函数的调用" << endl;
			delete(p_B);
			p_B = NULL;
		}
	}
	int* p_B;
};
int main()
{
	A* a = new B;
	delete(a);
}

看看运行的结果：

很明显少了一次我们对B的析构函数，但是我们的B在堆区开辟了一个空间，所以我们造成了内存泄漏。

那么这个过程是怎么样的呢？

第一个过程：

第二个过程：

我们都知道，我们应该先释放子类，然后再释放父类吧。关于原理前面文章讲过这里不细说。

形象比喻：有了爸爸才有儿子，儿子才刚刚生下来，坑定不能爸爸就挂了吧，所以先挂儿子，再挂爸爸。

到这里就没有然后了，程序就结束了，很明显，我们new的p_B还没有被释放，所以造成了内存的泄漏，那么我们又来看看为什么加上了virtual又能解决这个问题？

上新代码：

#include<iostream>
using namespace std;
class A
{
public:
	A()
	{
		cout << "A中构造函数的调用" << endl;
		p_A = new int(666);
	}
	virtual ~A()
	{
		if (p_A != NULL)
		{
			cout << "A中析构函数的调用" << endl;
			delete(p_A);
			p_A = NULL;
		}
	}
	int* p_A;
};
class B:public A
{
public:
	B()
	{
		cout << "B中构造函数的调用" << endl;
		p_B = new int(999);
	}
	 virtual ~B()
	{
		if (p_B != NULL)
		{
			cout << "B中析构函数的调用" << endl;
			delete(p_B);
			p_B = NULL;
		}
	}
	int* p_B;
};
int main()
{
	A* a = new B;
	delete(a);
}

调用析构函数的时候都先查表，然后找到自己相应的析构函数然后调用。

什么是纯虚析构函数呢？

纯虚构析构函数 就是纯虚函数加上析构函数，一般我们把函数设置纯虚函数都是不想这个类实例化，抽象出来的顶层父类，并且这个纯虚函数不能实现。 但是在纯虚析构这里不同 因为析构函数的调用顺序是派生类 成员类 基类，就算你基类是纯虚函数，编译器还是会产生对他的调用，所以要保证为纯虚析构提供函数体，如果你不做有的编译器会自动加上，但是有的编译器却会出现问题。如果不提供该析构函数的实现，将使得在析构过程中，析构无法完成而导致析构异常的问题。

这里面有一个误区:有人认为，virtual f()=0这种纯虚函数语法就是没有定义体的语义。其实，这是不对的。这种语法只是表明这个函数是一个纯虚函数，因此这个类变成了抽象类，不能产生对象。我们完全可以为纯虚函数指定函数体 。通常的纯虚函数不需要函数体，是因为我们一般不会调用抽象类的这个函数，只会调用派生类的对应函数。

纯虚析构需要注意的地方就是必须要提供函数体，狭隘的理解：
我们每次用虚析构函数 都是为了释放开辟出来的内存吧，如果我们的纯虚析构函数没有实现的话那么就无法发释放基类中开辟出来的内存空间。

为了不把大家弄混淆，不在这篇文章讨论另一个题外话下一篇文章我们来讨论：
假如我们没有在每个析构函数面前都加virtual会发生什么情况，分情况讨论。
假如我们就是B类本身类型接收，再加上virtual又会发生什么？

本篇文章讲解利用虚析构和纯虚析构函数去解决子类开辟在堆区的空间，释放子类开辟在堆区的空间，纯虚析构函数和虚析构的共同特点：必须要写实现，纯虚析构函数，类外写实现，虚析构函数类内写实现，都可以通过父类对象去释放子类开辟的空间（new出来的空间，开辟在堆区）
1：
代码如下：

#include<iostream>
#include<string>
using namespace std;
//抽象类
class father
{
public:
	//纯虚函数
	father()
	{
		cout << "father构造函数的调用！" << endl;
	
	}
	//纯虚函数不需要类外实现
	virtual void func() = 0;
	利用虚析构可以解决 父类指针释放子类对象不干净的问题
	//virtual ~father()//未加virtual之前无法通过父类对象清除子类开辟在堆区的空间
	//{
	//	cout << "father析构函数的调用！" << endl;

	//}
	//有了纯虚析构，该类也属于抽象类，无法实例化对象
	virtual ~father() = 0;//纯虚析构函数必须在类外写实现，否则运行的时候报错，必须要走的，所以要写实现
};
//类外写的纯虚析构记得加作用域
father::~father()
{
	cout << "father纯虚析构析构函数的调用！" << endl;
}

class son :public father
{
	
public:
	void func()
	{
		cout <<*M_name<< "虚函数的调用！" << endl;
	}
	string *M_name;
	son(string name)
	{
		cout << "子类构造函数的调用！" << endl;
		M_name = new string(name);//new关键字开辟的空间需要用指针去接收
	}
	~son()
	{
		if (M_name != NULL)
		{
			cout << "子类析构函数的调用！" << endl;
			delete M_name;
			M_name = NULL;
		}
	
	
	}
};
void func()
{
	father *f = new son("wan");//父类为抽象类，无法实例化对象，但是可以通过new一个子类的对象进行实例化，用指针接收
	f->func();
	delete f;

}
int main()
{
	func();
	system("pause");
	return 0;
}

virtual关键字的使用能够通过父类对象去访问子类的空间，即实现多态一定要写子类重写父类的虚函数，而虚析构和纯虚析构的使用可以进一步通过多态的方式去释放子类开辟在堆区的空间。