C++类与对象笔记十四：多态六：虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码。

即：父类指针无法调用子类实例对象内的析构函数。造成堆区内存泄漏。

解决方案:将父类中的析构函数改为虚析构或者纯虚析构。

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现。

虚析构和纯虚析构区别：

• 如果是纯虚析构，该类属于抽象类，无法实例化对象。

虚析构语法：virtual ~类名(){}

纯虚析构语法：virtual ~类名() = 0;

纯虚函数没有函数体；纯虚析构函数也没有函数体；类似声明，直接赋值为0。

父类将虚函数写为纯虚函数，是因为，子类调用不到，或者说不知道如何写，没有通用写法，所以干脆不要写。

看一个案例：

#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak() = 0;
};

class Cat : public Animal
{
	void speak()
	{
		cout << "小猫喵喵叫..." << endl;
	}
}; 

int main()
{
	Animal* animal = new Cat;  // 必须是指针或者应用类型，否则编译不过去。
	animal->speak();
	delete animal;
	

	system("pause");
	return 0;
}

以上是我们曾经写过的案例：现在我们想在子类Cat上，增加一些新的特性，这个特性是一个指针类型的；比如我们加一个指针类型的名字，这个特性指针保存在堆中。需要我们手动开辟，手动释放。

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


class Animal
{
public:
	virtual void speak() = 0;
};

class Cat : public Animal
{
public:
	Cat(string name)
	{
		m_Name = new string(name);
	}

	void speak()
	{
		cout << "小猫" << *m_Name << "喵喵叫..." << endl;  // 解引用
	}

private:
	string* m_Name;
}; 

int main()
{
	Animal* animal = new Cat("Tom");  // 必须是指针或者应用类型，否则编译不过去。
	animal->speak();
	delete animal;
	

	system("pause");
	return 0;
}

为了释放这个堆区的属性，我们需要写一个析构函数，来手动释放内存。

同时为了捕获执行的先后顺序，我们增加父类的构造函数和析构函数，在里面打印输出执行情况。

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


class Animal
{
public:
	Animal()
	{
		cout << "父类Animal构造函数执行完毕。" << endl;
	}
	~Animal()
	{
		cout << "父类Animal析构函数执行完毕。" << endl;
	}
	virtual void speak() = 0;
};

class Cat : public Animal
{
public:
	Cat(string name)
	{
		m_Name = new string(name);
		cout << "Cat类构造函数执行完毕。" << endl;
	}

	~Cat()
	{
		if (m_Name != NULL)   // 如果非空则释放。
		{
			delete m_Name;
			m_Name = NULL;
		}
		cout << "Cat类析构函数执行完毕。" << endl;
	}

	void speak()
	{
		cout << "小猫" << *m_Name << "喵喵叫..." << endl;  // 解引用
	}

private:
	string* m_Name;
}; 

int main()
{
	Animal* animal = new Cat("Tom");  // 必须是指针或者应用类型，否则编译不过去。
	animal->speak();
	delete animal;
	

	system("pause");
	return 0;
}

执行结果:

父类Animal构造函数执行完毕。
Cat类构造函数执行完毕。
小猫Tom喵喵叫...
父类Animal析构函数执行完毕。

问题：

我们发现：子类Cat的析构函数并没有执行。堆区数据没有释放干净，导致内存泄漏。

原因：

产生的原因：是因为我们用父类的指针指向了子类对象。所以当我们去delete父类指针时，并没有调用子类的析构函数，而是调用了父类的析构函数。导致子类如果有堆区的数据，会出现内存泄漏情况。

解决方案：

为了执行子类的析构函数，需要将父类的析构函数写为虚析构函数。此时就会执行子类的析构函数。把堆区数据释放干净。

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


class Animal
{
public:
	Animal()
	{
		cout << "父类Animal构造函数执行完毕。" << endl;
	}
	virtual ~Animal()
	{
		cout << "父类Animal析构函数执行完毕。" << endl;
	}
	virtual void speak() = 0;
};

class Cat : public Animal
{
public:
	Cat(string name)
	{
		m_Name = new string(name);
		cout << "Cat类构造函数执行完毕。" << endl;
	}

	~Cat()
	{
		if (m_Name != NULL)   // 如果非空则释放。
		{
			delete m_Name;
			m_Name = NULL;
		}
		cout << "Cat类析构函数执行完毕。" << endl;
	}

	void speak()
	{
		cout << "小猫" << *m_Name << "喵喵叫..." << endl;  // 解引用
	}

private:
	string* m_Name;
}; 

int main()
{
	Animal* animal = new Cat("Tom");  // 必须是指针或者应用类型，否则编译不过去。
	animal->speak();
	delete animal;
	

	system("pause");
	return 0;
}

输出： 

父类Animal构造函数执行完毕。
Cat类构造函数执行完毕。
小猫Tom喵喵叫...
Cat类析构函数执行完毕。
父类Animal析构函数执行完毕。

结论：

利用父类虚析构函数可以解决，父类指针释放子类对象时不干净的问题。

---

---

虚析构和纯虚析构二者只能有一个。 

---

---

 虚析构和纯虚析构都必须有代码实现：因为假设在父类中也有一些特性开辟在了堆中，那么就需要析构函数来释放，无论这个析构函数是不是虚的。

因此：以下代码会报错：

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


class Animal
{
public:
	Animal()
	{
		cout << "父类Animal构造函数执行完毕。" << endl;
	}
	// 析构函数
	//virtual ~Animal()
	//{
	//	cout << "父类Animal析构函数执行完毕。" << endl;
	//}
	// 纯虚析构函数
	virtual ~Animal() = 0;   // 只有一个声明，此时如果执行会报错。在链接阶段出现错误，因为析构函数必须要有一个函数实现。为啥？因为假设，我们在父类中也有一些属性开辟到内存堆中，就需要析构函数来释放。
	// 纯虚函数
	virtual void speak() = 0;
};

class Cat : public Animal
{
public:
	Cat(string name)
	{
		m_Name = new string(name);
		cout << "Cat类构造函数执行完毕。" << endl;
	}

	~Cat()
	{
		if (m_Name != NULL)   // 如果非空则释放。
		{
			delete m_Name;
			m_Name = NULL;
		}
		cout << "Cat类析构函数执行完毕。" << endl;
	}

	void speak()
	{
		cout << "小猫" << *m_Name << "喵喵叫..." << endl;  // 解引用
	}

private:
	string* m_Name;
}; 

int main()
{
	Animal* animal = new Cat("Tom");  // 必须是指针或者应用类型，否则编译不过去。
	animal->speak();
	delete animal;
	

	system("pause");
	return 0;
}

出错的原因

就在：父类的析构函数只有一个类似声明的存在，无法完成释放类空间的作用。

解决方案：

纯虚析构函数：类内声明；类外实现。

而且：

有了纯虚析构函数之后，这个类也就属于抽象类了。无法实例化对象。

---

---

---

总结：

如果子类在堆中有数据存放，而父类无法调用子类的析构函数，多态实现中，必须要将父类析构函数写为虚析构函数或者纯虚析构函数。

 主要解决的问题是：父类的指针或者引用无法调用子类的析构函数。导致父类无法释放子类在堆中的数据，从而会产生内存泄漏问题。

总结：

• 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
• 2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
• 3. 拥有纯虚析构函数的类也属于抽象类