C++学习--多态

多态是C++面向对象的特性之一
运行父类和子类对象的类型转换–不用强制类型转换

基本概念

1. 静态多态：函数重载和运算符重载 复用函数名
2. 动态多态：派生类和虚函数实现运行时多态

静态与动态的区别：

• 静态多态的函数地址早绑定：编译阶段确定函数地址
• 动态多态的函数地址晚绑定：运行阶段确定函数地址

实现动态多态的条件：

1. 有继承关系
2. 子类重写父类的虚函数–重写：函数返回值，名字，参数都一致

动态多态的使用：父类的指针或者引用，执行子类的对象

//地址早绑定，在编译阶段确定函数地址--都是执行Animal
void dospeak(Animal& animal) {
	animal.speak();

}
void test01() {
	Cat cat;
	dospeak(cat);//运行父类和子类对象的类型转换--不用强制类型转换
	//Animal& animal = cat;
	//添加虚函数之后就是小猫在说话
}

完整代码：添加虚函数之后就是小猫在说话

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

//多态
//目的实现动态绑定。cat说话，dog说话--虚函数
class Animal {
public:
	virtual void speak() {//添加虚函数
		cout << "动物在说话" << endl;
	}
	//void speak() {//添加虚函数
	//	cout << "动物在说话" << endl;
	//}
};
class Cat :public Animal {
public:
	void speak() {
		cout << "小猫在说话" << endl;
	}
};
//地址早绑定，在编译阶段确定函数地址--都是执行Animal
void dospeak(Animal& animal) {
	animal.speak();

}
void test01() {
	Cat cat;
	dospeak(cat);//运行父类和子类对象的类型转换--不用强制类型转换
	//Animal& animal = cat;
	//添加虚函数之后就是小猫在说话
}
int main() {

	test01();
	return 0;
}

多态的底层原理

virtual void speak() {//添加虚函数
		cout << "动物在说话" << endl;
	}
void speak() {
	cout << "动物在说话" << endl;
}

cout << "animal大小：" << sizeof(Animal);

在加虚函数之前，结果是1（只有成员变量才属于类的空间–空类占一个内存）；加虚函数之后结果是4（一个指针）；
构建一个虚函数表的指针： vfptr
继承会从父类中把虚函数表和指针继承到子类。

多态的优点：

1. 代码组织结构清晰
2. 可读性强
3. 利于前期和后期的扩展以及维护

多态案例：计算器类

使用条件：父类指针或引用指向子类对象AbstractCalculator* abc = new AddCalculator;

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

//利用多态实现计算器

//实现计算器抽象类
class AbstractCalculator {
public:
	virtual int getResult() {
		return 0;
	}
	int m_num1;
	int m_num2;
};

class AddCalculator:public AbstractCalculator {
	int getResult() {
		return m_num1 + m_num2;
	}
};
void test01() {
	//父类指针或引用指向子类对象
	AbstractCalculator* abc = new AddCalculator;
	abc->m_num1 = 100;
	abc->m_num2 = 50;

	cout<<abc->getResult();
	delete abc;
}
int main() {
	test01();
	return 0;
}

纯虚函数和抽象类

在多态中，通常父类中虚函数实现是毫无意义的，主要都是调用子类重写的内容。因此可以将虚函数改为纯虚函数。

语法：virtual 返回值类型 函数名（参数列表） = 0；当类中有了纯虚函数，这个类也叫抽象类。
抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

虚析构和纯虚析构

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

//比如
class Cat:public Animal{
public:
	//构造函数
	Cat(string name){
		//new一个属性值
		n_name = new string(name);
	}
	string* n_name;
	//析构函数
	~Cat(){
		if(n_name != NULL){
			delete n_name;
			n_name = NULL;
		}
	}
}

Animal *an = new Cat;
delete an;//析构时并不会调用Cat类的析构函数，无法delete n_name

析构时并不会调用Cat类的析构函数，无法delete n_name

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

虚析构或者纯虚析构共性：

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

虚析构或者纯虚析构区别：

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

必须要有函数实现。（可以类外实现）

virtual ~类名(){};
virtual ~类名() = 0;
//类外代码实现，子类不用重写animal的析构，父类中就virtual就可以
Animal::~Animal(){};