---

前言

  多态也是三大面向对象语言的特性之一，同时我也觉得他也蛮有意思的
  与封装“一个方法，多个接口”不同的是，多态可以实现 “一个接口，多种方法”

  调用同名函数时，可以根据不同的对象（父类对象或子类对象）调用属于自己的函数，实现不同的方法，因此 多态 的实现依赖于 继承

---

一、多态的概念

  在使用多态的代码中，不同对象完成同一件事会产生不同的结果

  比如在购买高铁票时，普通人原价，学生半价，而军人可以优先购票，对于 购票 这一相同的动作，需要 根据不同的对象提供不同的方法

二、多态的定义与实现

两个必要条件

1. virtual 修饰后形成的虚函数，与其他类中的虚函数形成 重写（三同：返回值、函数名、参数均相同）
2. 必须通过【父类指针】或【父类引用】进行虚函数调用

虚函数

  被virtual修饰的类成员函数称为虚函数

全局虚函数没有意义，因为虚函数是为多态而用的

虚函数的重写

  虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同(类型相同即可))，称子类的虚函数重写了基类的虚函数

// 基类
class Person 
{
public:
    // 虚函数
    virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

// 派生类
class Student : public Person 
{
public:
    // 虚函数重写
    virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

// 三种函数实现
// 引用
void Func(Person& p)
{
	p.BuyTicket();
}
 
// 指针
//void Func(Person* p)
//{
//	p->BuyTicket();
//}
 
// 非引用指针，调用父类
//void Func(Person p)
//{
//	p.BuyTicket();
//}

测试结果：

重写的三个例外

1. 协变(基类与派生类虚函数返回值类型不同)

  派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变

这个了解一下就行，实际我感觉挺没啥用处的
如果你也有这种感觉，鼓励你致电老本，去好好批斗他！

class A {};
class B : public A {};
 
class Person
{
public:
	// 协变 返回值可以是父子类对象指针或引用
	//virtual A* BuyTicket() // 返回值是父类指针
	virtual Person* BuyTicket()
	{
		cout << "Person-> 买票-全价" << endl;
		return nullptr;
	}
};

class Student : public Person
{
public:
	//virtual B* BuyTicket()// 返回值是子类指针
	virtual Student* BuyTicket()
	{
		cout << "Student-> 买票-半价" << endl;
		return nullptr;
	}
};

2. 析构函数的重写(基类与派生类析构函数的名字不同)

  如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor

class Person
{
public:
	// 析构函数名不同，构成重写，编译器将析构函数名字统一处理成destructor
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Student : public Person
{
public:
    virtual ~Student()
	{
		cout << "delete[]" << _ptr << endl;
		
		delete[] _ptr;
		cout << "~Student()" << endl;
	}
private:
	int* _ptr = new int[10];
};

void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	// 正常情况调用析构没有问题
	//Person p;
	//Student s;
	//Func(p);
	//Func(s);
 
	// 派生类有动态开辟的内存，需要调用多态
	// 指向谁调用谁
	Person* p1 = new Person;
	Person* p2 = new Student;
 
	delete p1;
	delete p2;
 
	return 0;
}

3. 派生类重写虚函数virtual关键字可以省略

class Person
{
public:
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};
 
class Student : public Person
{
public:
    // 派生类virtual关键字省略
	~Student()
	{
		cout << "~Student()" << endl;
	}
};

override 和 final

  C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载

1. final：修饰虚函数，表示该虚函数不能再被重写
2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

// final 修饰虚函数，不能重写
class Car
{
public:
	// 加了final关键字，虚函数不能被重写
	virtual void Drive() final {}
};

class Benz :public Car
{
public:
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};

int main()
{
	Benz b;
	return 0;
}

重载、重写(覆盖)、重定义(隐藏)

三、抽象类

概念

  在虚函数的后面写上 = 0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承

class Car
{
public:
	// 纯虚函数 强制派生类重写虚函数 
	virtual void Drive() = 0;
};

int main()
{
	Car c;
	return 0;
}

class Car
{
public:
	// 纯虚函数 强制派生类重写虚函数 
	virtual void Drive() = 0;
};

class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};

class BMW :public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};

int main()
{
	// Car c;
	Benz b1;
	BMW b2;
 
	// 基类可以定义指针 指向谁调用谁
	Car* ptr1 = &b1;
	Car* ptr2 = &b2;
 
	ptr1->Drive();
	ptr2->Drive();
	
	return 0;
}

接口继承和实现继承

  普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数

四、多态的原理

  在讲解原理之前，不如我们先来看这么一段神奇代码

#include <iostream>
using namespace std;

class Test
{
	virtual void func() {};
};

int main()
{
	Test t;	//创建一个对象
	cout << "Test sizeof(): " << sizeof(t) << endl;
	
	return 0;
}

  可能你会觉得没有对象，会觉得是0，但是你突然想起了之前讲过的空类也占内存空间，你可能会想是不是1

  但是其实都错了，真相是4/8（取决于你的系统是32位还是64位），可能我这么一说，你也猜到了其实有一个隐藏变量，且类型是指针类型

其实，就是靠着这个虚表指针和虚表实现了多态

虚表和虚表指针

  在 vs 的监视窗口中，可以看到涉及虚函数类的对象中都有属性 __vfptr（虚表指针），可以通过虚表指针所指向的地址，找到对应的虚表

  虚函数表中存储的是虚函数指针，可以在调用函数时根据不同的地址调用不同的方法

可能有点混，有三个“虚”，大家别被整虚了！
虚表指针指向虚表，虚表里面存放着虚函数指针，所以虚表的本质其实是个函数指针数组

  接下来我会给出一段代码，在该代码中父类 Person 有两个虚函数（func3 不是虚函数），子类 Student 重写了 func1 这个虚函数，同时新增了一个 func4 虚函数

#include <iostream>

using namespace std;

class Person
{
public:
	virtual void func1() { cout << "Person::fun1()" << endl; };
	virtual void func2() { cout << "Person::fun2()" << endl; };
	void func3() { cout << "Person::fun3()" << endl; };	//fun3 不是虚函数
};

class Student : public Person
{
public:
	virtual void func1() { cout << "Student::fun1()" << endl; };

	virtual void func4() { cout << "Student::fun4()" << endl; };
};

int main()
{
	Person p;
	Student s;
	
    return 0;
}

//打印虚表
typedef void(*VF_T)();

void PrintVFTable(VF_T table[])	//也可以将参数类型设为 VF_T*
{
	//vs中在虚表的结尾处添加了 nullptr
	//如果运行失败，可以尝试清理解决方案重新编译
	int i = 0;
	while (table[i])
	{
		printf("[%d]:%p->", i, table[i]);
		VF_T f = table[i];
		f();	//调用函数，相当于 func()
		i++;
	}
	cout << endl;
}


int main()
{
	//提取出虚表指针，传递给打印函数
	Person p;
	Student s;

	//第一种方式：强转为虚函数地址（4字节）
	PrintVFTable((VF_T*)(*(int*)&p));
	PrintVFTable((VF_T*)(*(int*)&s));

	return 0;
}

子类重写后的虚函数地址与父类不同

因为平台不同指针大小不同，因此上述传递参数的方式(VF_T * )( * (int * )&p 具有一定的局限性
假设在 64 位平台下，需要更改为 (VF_T * )( * (long long * )&p

//64 位平台下指针大小为 8字节
PrintVFTable((VF_T*)(*(long long*)&p));
PrintVFTable((VF_T*)(*(long long*)&s));

除此之外还可以间接将虚表指针转为 VF_T* 类型进行参数传递

//同时适用于 32位 和 64位 平台
PrintVFTable(*(VF_T**)&p);
PrintVFTable(*(VF_T**)&s);

传递参数时的类型转换路径

  不能直接写成 PrintVFTable((VF_T*)&p);，因为此时取的是整个虚表区域的首地址地址，无法定位我们所需要虚表的首地址，打印时会出错

  综上所述，虚表是真实存在的，只要当前类中涉及了虚函数，那么编译器就会为其构建相应的虚表体系

虚表是在 编译 阶段生成的
虚表指针是在构造函数的 初始化列表 中初始化的
虚表一般存储在 常量区（代码段），有的平台中可能存储在 静态区（数据段）

int main()
{
	//验证虚表的存储位置
	Person p;
	Student s;

	int a = 10;	//栈
	int* b = new int;	//堆
	static int c = 0;	//静态区（数据段）
	const char* d = "xxx";	//常量区（代码段）

	printf("a-栈地址：%p\n", &a);
	printf("b-堆地址：%p\n", b);
	printf("c-静态区地址：%p\n", &c);
	printf("d-常量区地址：%p\n", d);

	printf("p 对象虚表地址：%p\n", *(VF_T**)&p);
	printf("s 对象虚表地址：%p\n", *(VF_T**)&s);

	return 0;
}

显然，虚表地址与常量区的地址十分接近，因此可以推测 虚表 位于常量区中，因为它需要被同一类中的不同对象共享，同时不能被修改（如同代码一样）

虚函数调用过程

综上，我们可以大概想象出多态的原理了：

1. 首先确保存在虚函数且构成重写
2. 其次使用【父类指针】或【父类引用】指向对象，其中包含切片行为
3. 切片后，将子类中不属于父类的切掉，只保留父类指针可调用到的部分函数
4. 实际调用时，父类指针的调用逻辑是一致的：比如虚表第一个位置调用第一个函数，虚表第二个位置调用第二个函数，但是因为此时的虚表是切片得到的，所以 同一位置 可以调用到不同的函数，这就是多态

也就是说，父类和子类的虚表其实是不一样的，在构成重写的前提下！
这就是多态！

int main()
{
	Person* p1 = new Person();
	Person* p2 = new Student();

	p1->func1();
	p2->func1();

	delete p1;
	delete p2;
	return 0;
}

通过汇编代码来看的话：

动态绑定与静态绑定

  其实我们想一想，函数重载某种程度上也是一种多态，也是一个函数面对不同对象的时候有不同的效果，但是不同的是，重载在编译的时候就确定了待调用函数的地址，而动态绑定的代码，待调用地址存放在 eax 中，不确定

五、那…那单继承甚至多继承呢？

  坦白说，这很麻烦，我也不敢说我很懂，于是我在这里贴两篇文章，大家自行参阅吧！

《C++虚函数表解析》
《C++对象的内存布局》

---

总结

  我们终于学完三大面向对象特性了，坦白说，多态还是蛮困难的，但是，我们难度的最高峰再过几篇就要来了，怕不怕！