C++核心编程——4.7 多态

4.7.1 多态的基本概念

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

多态表示提供一个公共的函数接口，当传入不同参数对象时，执行不同的函数实现。

语法	virtual 返回值类型 函数名()  {}
分类	静态多态	动态多态（加“virtual“）
	函数重载 和 运算符重载 （复用函数名，函数/运算符用多种方式表示 ）	派生类和虚函数实现 （父类必须写“virtual“，子类可写可不写）
	地址早绑定（编译阶段确定）	地址晚绑定（运行阶段确定）
满足条件	1、有继承关系 2、子类重写父类中的虚函数 （函数返回值类型、函数名、参数列表完全相同，与重载不同）
使用方法	父类的指针/引用 指向 子类对象
语法	（引用） 父类类名 & 父类对象 = 子类类名	（指针） 父类类名 * 父类对象 = new 子类类名
例子	Animal & animal  = Cat	AbstractCalculator *abc = new AddCalculator

//动物类
class Animal
{
public:
	//Speak函数就是虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
//派生类
class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog :public Animal
{
public:
	void speak()
	{
		cout << "小狗在说话" << endl;
	}

};

//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编

void DoSpeak(Animal & animal) //用引用的方式传递
{
	animal.speak();
 //定义里面是Animal后无论后面再传入什么对象（cat/dog）都会执行Animal里面的，此时地址早绑定
 //如果要传入特定对象（cat/dog）后执行特点对象里面的内容，就需要地址晚绑定 加“virtual“（父类必须写，子类可写可不写
}
void test01()
{
	Cat cat;
	DoSpeak(cat);

	Dog dog;
	DoSpeak(dog);
}
int main() {

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

4.7.2 纯虚函数和抽象类

问题： 在多态中父类的虚函数实现基本不会调用，主要都是调用子类重写的内容

方案：将虚函数改为纯虚函数（就是为了让子类重写虚函数（多态），否则没有任何意义）

语法（必须在虚函数的基础上）：virtual 返回值类型 函数名 （参数列表）= 0 ;

特点：

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

堆/栈上都无法无法实例化对象（对象没有意义）

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

class Base
{
public:
	virtual void func() = 0;
};

class Son :public Base
{
public:
	virtual void func() 
	{
		cout << "func调用" << endl;
	};
};

void test01()
{
	Base * base = NULL;
	//base = new Base; // 错误，抽象类无法实例化对象
	base = new Son;
	base->func();
	delete base;//记得销毁
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.7.3 虚析构和纯虚析构

问题：子类中有堆区开放数据时，父类指针在释放时无法调用到子类的析构代码，会造成数据泄露

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

	虚析构	纯虚析构
语法	virtual ~类名(){}	virtual ~类名() = 0; 类名::~类名(){}
	有具体的函数实现	类内没有具体的函数，但类外必须加上，否则连接时报错
		有纯虚析构，该类属于抽象类，无法实例化对象
特点	两者只能保留其一（子类中没有堆区数据，可以不写为虚析构或纯虚析构）

class Animal {
public:

	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	virtual void Speak() = 0;

	//析构函数加上virtual关键字，变成虚析构函数
	//virtual ~Animal()
	//{
	//	cout << "Animal虚析构函数调用！" << endl;
	//}

//纯虚析构和虚析构只能有一个，不能同时存在
	virtual ~Animal() = 0;  //只有声明没有实现会在链接的时候报错，必须有具体的实现
};

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

//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用！" << endl;
		m_Name = new string(name);
        //new的是string，返回的就是string的指针
	}
	virtual void Speak()
	{
		cout << *m_Name <<  "小猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat析构函数调用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}

public:
	string *m_Name;      //让小猫的名字创建在堆区，用该指针进行维护
};

void test01()
{
	Animal *animal = new Cat("Tom");
	animal->Speak();
    
	//虚析构函数就是用来解决通过父类指针释放子类对象
	delete animal;
}

int main() {

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