C++：类和对象：多态

1：多态的基本概念

多态就是指多种状态，它是 C++面向对象三大特性之一。

多态分为两类

1：静态多态：函数重载和运算符重载。

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

静态多态和动态多态区别：

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

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

案例：假设我们有个动物类Animal ，还有个继承自动物类的 猫类  Cat。 动物类和猫类都有一个 speak成员函数，分别打印：动物在说话和 猫在说话。

现在如果我们有一个 doSpeak函数，函数的参数是动物类的引用 Animal& animal，现在我们创建一个 猫类对象 cat，然后以引用的方式传入 doSpeak函数。我们看看结果是调用 动物类还是猫类的 成员函数。

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

class Animal {
public:
	void speak() {
		cout << "动物在说话" << endl;
	}
};

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

// 父类的引用指向一个 接收的子类对象
// 允许父类和子类之间的类别转换
// 地址是 早绑定，可以在编译阶段确定函数地址
void doSpeak(Animal& animal) {
	animal.speak();
}

void test() {
	Cat cat;
	doSpeak(cat);
}

int main() {
	test();
	return 0;
}

 

 打印结果表明：虽然传入的是猫类的引用，但是doSpeak函数是以动物类的引用 去接收 猫类对象，然后在调用 speak() ，所以speak函数的地址是早绑定的，不管传入什么类的对象都会调用动物类的 speak函数。

如何解决这个问题？

引入虚函数

在Animal 的speak成员函数前面添加 virtual ，使得Animal 的speak成员函数成为一个虚函数，然后在子类中重写这个 speak函数。

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

class Animal {
public:
	// 将speak函数声明为虚函数，那么编译器在编译的时候就不能确定函数调用地址。
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal {
public:
	// 重写父类的speak函数： 函数返回值，函数名，参数列表完全相同。
	// 子类重写：可以不加 virtual
	void speak() {
		cout << "小猫在说话" << endl;
	}
};

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

// 我们希望 它具备类型 java多态的功能
// 1: 传入什么对象，那么就调用什么对象的函数
// 2: 如果函数地址在编译阶段就能确定，那么就是 静态联编
// 3：如果函数地址在运行阶段才能确定，那么就是 动态联编
void doSpeak(Animal& animal) {
	animal.speak();
}

// 多态满足的条件
// 1: 有继承关系
// 2: 子类重写父类中的虚函数
// 多态使用 ： 父类指针或引用指向子类对象
void test() {
	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
}

int main() {
	test();
	return 0;
}

 

运行结果可知

传入小猫对象，就可以打印小猫在说话

传入小狗对象，就可以打印小狗在说话

事项了运行时多态，即函数地址晚绑定。 

总结：

1：动态多态满足条件：有继承关系，子类重写父类中的虚函数。

2：动态多态使用条件：父类指针或引用指向子类对象。

3：重写：函数返回值，函数名，参数列表完全一直称为重写。 

2：多态原理剖析 

案例：我们分别创建两个类Animal1 和 Animal2 ，其中Animal1没有实现动态多态，Animal2实现了动态多态，然后看下它们的大小分别是多少。

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

class Animal1 {
public:
	void speak() {
		cout << "动物1在说话" << endl;
	}
};

class Animal2 {
public:
	virtual void speak() {
		cout << "动物2在说话" << endl;
	}
};

int main() {
	cout << "the size of 原始 = " << sizeof(Animal1) << endl;
	cout << "the size of 多态 = " << sizeof(Animal2) << endl;
	return 0;
}

 

从打印结果我们可以这样推测

1：由于成员函数和类时分开存储的，所以 Animal1 是一个空类，大小为1个字节，这个没什么疑问

2：而Animal2大小为 4个字节，也就是一个 int 指针大小，这个指针我们称为虚函数指针，指向虚函数表，而虚表里面保存的就是 Animal类的成员函数 speak地址。（下面我们通过VS开发人员工具看看结构）

Animal2 内存结构

 1：可以看到Animal2 大小为4字节：也就是一个 int 指针大小，这个指针我们称为虚函数指针，指向虚函数表，而虚表里面保存的就是 Animal类的成员函数 speak地址。

 2： 在看下 Animal3 的结构

可以看到：Animal3 大小也是4字节，继承了 Animal2的虚函数指针，指向了 Animal3类的虚函数表。Anmial3类的虚函数表中保存的也是 Animal2类成员函数speak地址。

下面我们通过一张图来深化总结一下。 

总结：

1：子类继承父类时，会将父类的虚函数表和虚函数指针都继承下来

2：如果子类重写父类的虚函数时，子类中的虚函数表中的内容就会替换成子类的虚函数地址，而父类中的虚函数表内容不变，这时如果父类的指针或者引用指向子类对象，就会发生多态。

4：纯虚函数和抽象类 

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

纯虚函数语法：

virtual 返回值类型 函数名（参数列表） = 0；

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

抽象类特点：

1：无法实例化对象

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

案列： 

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

class Base {
public:
	// 纯虚函数
	// 类中只要有一个纯虚函数就是把这个类称为 抽象类
	// 抽象类无法实例化对象
	// 子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void speak() = 0;
};

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

int main() {
	Base* base = NULL;
	// base = new Base;  // error 抽象类无法实例化对象
	base = new Son;
	base->speak();
	delete base;
	return 0;
}

打印结果可知：

如果父类中包含纯虚函数，那么他就是个抽象类，子类重写父类的抽象函数，父类的指针指向子类时，如果调用父类的纯虚函数，这时会调用子类重写后的虚函数。 

6：虚析构和纯虚析构 

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

案例：创建一个父类 Animal ，添加纯虚成员函数 speak，在构造函数和析构函数中添加打印语句。创建一个子类 Cat, ，重写speak函数，在构造函数和析构函数中添加打印语句，创建一个父类指针指向子类对象，然后父类指针调用父类的speak函数，我们看下构造函数和析构函数情况。

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

class Animal {
public:
	// 纯虚函数
	// 类中只要有一个纯虚函数就是把这个类称为 抽象类
	// 抽象类无法实例化对象
	// 子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void speak() = 0;

	Animal() {
		cout << "Animal的构造函数调用" << endl;
	}

	~Animal() {
		cout << "Animal的析构函数调用" << endl;
	}
};

class Cat :public Animal {
public:
	string* m_Name;
	virtual void speak() {
		cout << "小猫在说话" << endl;
	}
	Cat(string name) {
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	~Cat() {
		if (m_Name)
		{
			cout << "Cat析构函数调用" << endl;
			delete(m_Name);
			m_Name = NULL;
		}
	}
};

int main() {
	Animal* animal = new Cat("Tom");
	animal->speak();
	delete animal;
	return 0;
}

运行结果可知：并没有调用子类的析构函数，导致子类堆区上的数据没有被释放，会造成内存泄漏。

原因就是：

 我们使用父类指针指向子类对象，父类指针在析构时，没有调用子类的析构代码，导致子类如果在堆区的数据会出现内存泄漏的情况。

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

1：将析构函数修改为虚析构函数 

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

class Animal {
public:
	// 纯虚函数
	// 类中只要有一个纯虚函数就是把这个类称为 抽象类
	// 抽象类无法实例化对象
	// 子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void speak() = 0;

	Animal() {
		cout << "Animal的构造函数调用" << endl;
	}

	virtual ~Animal() {
		cout << "Animal的析构函数调用" << endl;
	}
};

class Cat :public Animal {
public:
	string* m_Name;
	virtual void speak() {
		cout << "小猫在说话" << endl;
	}
	Cat(string name) {
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	~Cat() {
		if (m_Name)
		{
			cout << "Cat析构函数调用" << endl;
			delete(m_Name);
			m_Name = NULL;
		}
	}
};

int main() {
	Animal* animal = new Cat("Tom");
	animal->speak();
	delete animal;
	return 0;
}

 

打印结果：可以调用子类的析构函数。 

2：将析构函数修改为纯虚析构函数  

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

class Animal {
public:
	// 纯虚函数
	// 类中只要有一个纯虚函数就是把这个类称为 抽象类
	// 抽象类无法实例化对象
	// 子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void speak() = 0;

	Animal() {
		cout << "Animal的构造函数调用" << endl;
	}

	virtual ~Animal() = 0;
};

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

class Cat :public Animal {
public:
	string* m_Name;
	virtual void speak() {
		cout << "小猫在说话" << endl;
	}
	Cat(string name) {
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	~Cat() {
		if (m_Name)
		{
			cout << "Cat析构函数调用" << endl;
			delete(m_Name);
			m_Name = NULL;
		}
	}
};

int main() {
	Animal* animal = new Cat("Tom");
	animal->speak();
	delete animal;
	return 0;
}

运行可知：成功调用了Cat的析构函数。 

总结

1：虚析构和纯虚析构共性：

-----都可以解决父类指针释放子类对象

------都需要有具体的函数实现

2：虚析构和纯虚析构区别：

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

3：虚析构语法：

virtual ~类名() {}

4: 纯虚析构语法：

virtual ~类名() = 0;

类名:: ~类名() {}