如何区别虚析构和纯虚析构函数?纯虚函数和抽象类?以及多态实现

咱们废话不多说，围绕主题进行讲解虚析构函数和纯虚析构函数的区别和如何写C++的多态实现，主要以基础入手为主，实现简单点的。

虚析构函数和纯虚析构函数区别在哪里？作为两点介绍：

1、虚析构函数：

主要作用是为了来解决基类指针指向派生类对象，并用基类指针释放派生类对象。也就是说父类的虚析构函数，会调用派生类的析构函数。有虚析构函数的类是抽象类，不能实例化对象，不需要在类外实现；

2、纯虚析构函数：

有纯虚析构函数的类它是抽象类，不能实例化对象，而且要在类外实现；

既然我们要实现一个简单的多态例子，首先也需要了解知道什么是多态？

既然我们要实现一个简单的多态例子，首先也需要了解知道什么是多态？简而言之，可以这么理解为“同一个操作作用于不同的对象，可以有不同的解释，会产生不同的效果，这就是多态。”

什么是纯虚函数？

class Maker
{
public:
    // 为纯虚函数
    virtual int getsize(int a, int b) = 0;
};

什么是抽象类？

有纯虚函数的类叫抽象类，不能实例化对象，同时如果是虚函数必须要实现，如果不实现，编译器就会报错。

为什么要用多态？多态有什么用处？

在类中使用多态一个可以解决项目中的紧耦合问题，提供程序的可扩展性；二是应用程序不必再为每一个子类的功能调用编写代码，只需要对抽象的父类进行处理就好。

实现多态需要满足哪几个条件？

实现多态一般满足这3个条件即可，要有继承，重写父类的虚函数，父类指针指向子类对象。

以上，我们把所有需要的条件和知识点进行梳理了，现在，我们以代码的形式写一个例子，方便更好理解和应用所提到的知识点。就以学校类和增加学科作为例子。代码如下所示：

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

// 学校类
class School {
public:
	virtual void study() = 0; // 父类的纯虚函数
};

// 1.有继承
class Math :public School
{
public:
	Math(string name)
	{
		this->name = name;
	}
	// 2.重写父类的虚函数
	virtual void study()
	{
		cout << "小明正在学" << this->name << endl;
	}
private:
	string name;
};

class Chinese :public School
{
public:
	Chinese(string name, string type)
	{
		this->name = name;
		this->type = type;
	}
	virtual void study()
	{
		cout << "在" << this->name << "中，小华的" << this->type << "基础很好！" << endl;
	}
private:
	string name;
	string type;
};

class Sports :public School
{
public:
	Sports(string name, int score)
	{
		this->name = name;
		this->score = score;
	}
	virtual void study()
	{
		cout << "小花的" << this->name << "成绩考了" << this->score << "分！" << endl;
	}
private:
	string name;
	int score;

};

// 增加学科
class Subject
{
public:
	Subject()
	{
		mCapacity = 1024;
		mSize = 0;
		//申请空间，存储School*的空间，指针数组
		this->s = new School*[mCapacity];
	}
	//增加学科
	int AddSubject(School* school)
	{
		if (mCapacity == mSize)
		{
			return -1;
		}
		//把指针存储到指针数组
		this->s[mSize] = school;
		mSize++;
		return 0;
	}
	void StartStudy()
	{
		for (int i = 0; i < mSize; i++)
		{
			s[i]->study();
		}
	}
	//析构函数
	~Subject()
	{
		//先释放指针数组中指针指向的堆区空间
		for (int i = 0; i < mSize; i++)
		{
			if (s[i] != NULL)
			{
				delete s[i];
				s[i] = NULL;
			}
		}
		//释放指针数组
		if (s != NULL) {
			delete[] s;
			s = NULL;
		}
	}
private:
	School **s;
	int mCapacity;//容量
	int mSize;
};

void test()
{
	// 3.父类指针指向子类的对象
	//创建学科
	Subject *subject = NULL;
	subject = new Subject;
	//添加学科
	subject->AddSubject(new Math("数学"));
	subject->AddSubject(new Chinese("语文", "文言文"));
	subject->AddSubject(new Sports("体育", 90));
	subject->StartStudy();
	// 释放
	delete subject;
	subject = NULL;
}

int main() {
	test();
	system("pause");
	return EXIT_SUCCESS;
}

代码实现结果为如下图所示：

总结：以上就是多态的简单实现例子，有一点需要注意一下：如果子类继承了抽象类，子类必须实现抽象类的所有纯虚函数，不然子类也变为抽象类。