【C++编程语言】之 多态的基本概念 ，纯虚函数和抽象类，虚析构和纯虚析构

1.多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类

​ 1.静态多态：函数重载，运算符重载属于静态多态，复用函数名

​ 2.动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态区别

​ 1.静态多态的函数地址早绑定 ------ 编译阶段确定函数地址

​ 2.动态多态的函数地址晚绑定 ------- 运行阶段确定函数地址

动态多态满足条件

	1.有继承关系
	2.子类重写父类的虚函数

动态多态使用

​ 父类的指针或引用，执行子类对象

重写：函数返回值类型，函数名，参数列表，完全一致成为重写

动态多态和静态多态的代码演示

//动物类
class Animal{
   	public:
    	//虚函数
        virtual void speak(){
        	cout <<"动物在说话"<<endl;
    	}
};
//猫类
class Cat :public Animal{
    public:
    	void speak(){
        	cout <<"小猫在说话"<<endl;
    	}
}; 
//狗类
class Dog :public Animal{
    public:
    	virtual void speak(){
        	cout <<"小狗在说话"<<endl;
    	}
};
//执行说话函数
void doSpeak(Animal &animal){//Animal &animal = cat 引用
    animal.speak();
}
void test01(){
    Cat cat;
    doSpeak(cat);
    //输出为 动物在说话，因为地址早绑定，在编译阶段确定函数地址
    //如果想执行让猫说话，那么这个函数地址就不能提前绑定，
    //需要在运行阶段进行绑定。
    Dog dog;
    doSpeak(dog);//在加上virtual后，输出为  小狗在说话
}

2.多态案例01----计算机类类

案例描述：

​ 分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算机器类

多态的优点

​ 1.代码组织结构清晰

​ 2.可读性强

​ 3.利用前期和后期的扩展以及维护

普通的实现

//普通写法
class Calculator {
public :
	int getResult(string oper) {
		if (oper == "+") {
			return m_Num1 + m_Num2;
		}
		else if (oper == "-") {
			return m_Num1 - m_Num2;
		}
		else if(oper == "*") {
			return m_Num1 * m_Num2;
		}
		//如果想扩展新的功能，需要修改源码
		//在真的开发中 提倡  开闭原则
		//开闭原则：对扩展进行开发，对修改进行关闭
	}
	int m_Num1;//操作数1
	int m_Num2;//操作数2
};
void test01() {
	//创建计算器对象
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << "+" << 
					c.m_Num2 << "=" << c.getResult("+") << endl;
	cout << c.m_Num1 << "-" << 
					c.m_Num2 << "=" << c.getResult("-") << endl;
	cout << c.m_Num1 << "*" << 
					c.m_Num2 << "=" << c.getResult("*") << endl;
}
int main() {
	test01();
}

多态版本

class AbstractCalcuator {
public:
	virtual int getResult() {
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
class AddCalculator :public AbstractCalcuator {
public:
	int getResult() {
		return m_Num1+ m_Num2;
	}
};
class SubCalculator :public AbstractCalcuator {
public:
	int getResult() {
		return m_Num1 - m_Num2;
	}
};
class MulCalculator :public AbstractCalcuator {
public:
	int getResult() {
		return m_Num1 * m_Num2;
	}
};
void test02() {
	//多态使用条件
	//父类指针或者引用指向子类对象
	AbstractCalcuator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" 
							<< abc->getResult() << endl;
	//用完记的销毁
	delete abc;
}
int main() {
	test02();
}

3.纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0；

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

​ 1.无法实例化对象

​ 2.子类必须重写抽象类中的纯虚函数，否则也属于抽象类

//虚函数和抽象类
class Base {
public:
	//纯虚函数
	//只要有一个纯虚函数，这个类称为抽象类
	/*
	*	抽象类特点
		1.无法实例化对象
		2.子类必须重写抽象类中的纯虚函数，否则也属于抽象类
	*/
	virtual void func() = 0;
};
class Son :public Base {
	virtual void func() {
		cout << "func函数调用" << endl;
	}
};
void test03() {
	//Base b;  抽象类是无法实例化对象
	//new Base;抽象类是无法实例化对象 
	//Son s; 子类必须重写抽象类中的纯虚函数，
	//否则也属于抽象类 抽象类无法实例化对象
	Base * base = new Son ;
	base->func();
}
int main() {
	test03();
	system("pause");
	return 0;
}

4.多态案例02----制作饮品

案例描述：

​ 制作饮品的大致流程为：煮水 — 冲泡 — 倒入杯中 — 加入辅料

​ 利用多态技术实现案例，提供抽象制作饮品的基类，提供子类制作咖啡和茶叶

//多态的案例二  制作饮品
class AbstractDrinking {
public:
	//煮水
	virtual void Boli() = 0;

	//冲泡
	virtual void Brew() = 0;

	//倒入杯子
	virtual void PourInCup() = 0;

	//加入辅料
	virtual void PutSomething() = 0;

	//制作饮品
	 void makeDrink() {
		 Boli();
		 Brew();
		 PourInCup();
		 PutSomething();
	}
};
//制作咖啡
class Coffee :public AbstractDrinking {
	//煮水
	virtual void Boli() {
		cout<<"煮农夫山泉" << endl;
	}

	//冲泡
	virtual void Brew() {
		cout << "冲泡咖啡" << endl;
	}

	//倒入杯子
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}

	//加入辅料
	virtual void PutSomething() {
		cout << "加入糖和牛奶" << endl;
	}
};
class Tea :public AbstractDrinking {
	//煮水
	virtual void Boli() {
		cout << "煮山泉水" << endl;
	}

	//冲泡
	virtual void Brew() {
		cout << "冲泡茶叶" << endl;
	}

	//倒入杯子
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}

	//加入辅料
	virtual void PutSomething() {
		cout << "什么都不加" << endl;
	}
};
//制作饮品函数
void doWork(AbstractDrinking *abc) {
	abc->makeDrink();
	delete abc;
}
void test01() {
	//制作咖啡
	//第一种创建和调用
	AbstractDrinking * c = new  Coffee;//（new是堆区数据需要释放）
	doWork(c);
	//第二种创建和调用
	//doWork(new Coffee);

	//制作茶
	doWork(new Tea);
}
int main() {
	test01();
	system("pause");
	return 0;
}

5.虚析构和纯虚析构

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

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

虚析构和纯虚构共性：

​ 1.可以解决父类指针释放子类对象

​ 2.都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

​ virtual ~类名（）{}

纯虚析构语法：

​ virtual ~类名（）{} = 0；

class Animal {
public:
	//纯虚函数
	virtual void speak() = 0;
	Animal() {
		cout << "Animal的构造函数调用" << endl;
	}
	//第一种解决方法
	/*利用虚析构可以解决 父类指针释放子类对象时不干净问题
	virtual~Animal() {
		cout << "Animal的析构函数调用" << endl;
	}
	*/

	//第二种解决方法
	//纯虚析构，纯虚析构函数需要重写，才可以编译通过。
	virtual ~Animal() = 0;
};

//纯虚析构函数的实现
Animal :: ~Animal() {
	cout << "Animal的纯虚析构函数调用" << endl;
}

class Cat :public Animal {
public:
	string * m_Name;
	Cat(string name) {
		cout << "cat的构造函数调用" << endl;
		//目前堆区创建属性了
		m_Name = new string(name);
	}
	~Cat() {
		if (m_Name != NULL) {
			cout << "cat的析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	virtual void speak() {
		cout<<*m_Name <<"小猫会说话" << endl;
	}
};

void test01() {
	Animal* animal = new Cat("汤姆");
	animal->speak();
	delete animal;
}
int main() {
	test01();
	/*运行结果
		Animal的构造函数调用
		cat的构造函数调用
		汤姆小猫会说话
		Animal的析构函数调用
		没有走cat的析构函数，m_Name指针指向堆区的数据没有释放，
													造成数据泄露
	出现这种情况的原因：
			父类指针在析构时候，不会调用子类中的析构函数，导致子类如果有
											堆区属性，出现内存泄露
	解决方法：
			把父类的析构函数 加 virtual 变成虚析构
	此时运行结果
		Animal的构造函数调用
		cat的构造函数调用
		汤姆小猫会说话
		cat的析构函数调用
		Animal的析构函数调用

	*/
	system("pause");
	return 0;
}