【C++】多态

一、多态的定义及实现

【概念】：

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会
产生出不同的状态。

例子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人
买票时是优先买票。

【多态的构成条件】：

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

1.1 虚函数

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

class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

其他函数就不行。 

 上图也就是所说虚函数以及虚继承可以是虚拟的

1.2 虚函数的重写

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

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
    // void BuyTicket() { cout << "买票-半价" << endl; } // 派生类不加virtual也可以
    //在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(重写的是虚函数的实现，继承父类的函数的接口// 不理解没事，有下面的题 ),但是该种写法不是很规范，不建议
这样使用
};

必须通过基类的指针或者引用调用虚函数 （下面代码和图为证明）

void Func(Person& p) // void Func(Person *p)
{
	p.BuyTicket();// p->BuyTicket();
}

 

 子类和父类中有同名成员，这种情况叫隐藏，也叫重定义。也就是说下图中不同类域中的BuyTicket之间也是有隐藏关系的 

（有些概念不清楚可以看我上篇写的继承） 

派生类屏蔽了父类同名函数BuyTicket，打印的是半价，指定类域后打印的是全价 

 可以认为重写是一种特殊的隐藏。隐藏包含重写。

【虚函数重写的两个例外】

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

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

class A {};
class B : public A {};
class Person {
public:
	virtual A* f() { cout << "virtual A* f()" << endl; return new A; }
};
class Student : public Person {
public:
	virtual B* f() { cout << "virtual B* f()" << endl; return new B; }
};

A是父类B是子类，Person虚函数返回A类对象(父类且是指针或者引用)，Student虚函数返回B类对象(子类且是指针或者引用)

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

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

上面的话没有理解没关系，我们看下面证明 

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

 先去掉基类与派生类virtual。

下图，因为Student是派生类，Student的析构函数会在被调用完成后自动调用Person的析构函数清理基类成员。

 下图，当父类的指针指向一个子类对象空间时，p1指向Student对象空间

发现编译器只显示了~person，为什么只析构了父类的析构函数？没有调到子类的析构？

因为delete p1的构成是p1->destructor() + operator delete(p1)

此外子类与父类的析构函数名构成了隐藏，所以发生的是父类的析构

如何解决？

在父类的析构和子类的析构 + virtual

让他们构成多态，通过Person的指针p1调用虚函数destructor，p1指向的是student的空间调用的是student的析构，student的析构结束后自动调用person的析构（多态调用，看指向对象类型，指向谁，调用谁的虚函数。-----这里是因为虚表的内容发生了重写覆盖）-----后的话不理解没事，看我三、虚函数表与多态的原理回过来再看

【例题】 

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};
class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

这里会输出什么？？？

首先，main函数中 指针p指向的是B类空间。其次，p指向test()，B中没有去A类找，此时这个test中调用的是func()，我们把test中的函数补充完整 this->func(); 此时这里的this是A的指针， 最后调用的是A的接口，实现的是B的函数，最后答案是 B->1

这里我简化一下什么是接口方便大家理解 

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
};
class B : public A
{
public:
	virtual void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{
	A* p = new B;
	p->func();
	return 0;
}

 多态调用，指向B对象类型，调用A类的接口也就是  void func(int val = 1) 实现B中的std::cout << "B->" << val << std::endl;  最后答案是 B->1

1.3 C++11 override 和 final

C++11提供了override和final两个关键字，可以帮助用户检测是否重写 

1. final：修饰虚函数，表示该虚函数不能再被重写

class A 
{
public:
	virtual int C() final { return 0; }
};
class B :public A
{
	int C() { return 0; }
};

2.final：修饰基类，表示不能被继承

class A final
{
public:
	virtual int C() { return 0; }
};
class B :public A
{
	int C() { return 0; }
};

1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class A 
{
public:
	int C() { return 0; }
};
class B :public A
{
	virtual int C() override { return 0; }
};

 上面的代码发生编译报错

二、抽象类

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

class Car
{
public:
	virtual void Drive() = 0;
};

class Benz :public Car
{
public:
};

Benz上面继承了Car不能实例化出对象

 只有重写虚函数

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

三、虚函数表与多态的原理

3.1 虚函数表

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

这个Base对象多少个字节？

答案是：8 字节

为什么？

 我们不难发现这里，除了_b成员，还多一个__vfptr放在对象的前面

所以Base对象有8个字节

对象中的这个指针我们叫做虚函数表指针，一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

我们通过下面的代码演示一下  

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};

void F(Base* p)
{
	// 运行时绑定/动态绑定
	p->Func1();
	// 编译时绑定/静态绑定
	p->Func3();
}

int main()
{
	Base b;
	Derive d;
	F(&b);
    F(&d);
	return 0;
}

我们先看b对象的成员 

 我们不难发现虚函数表指针存储的是0x00331082，0x00331398

虚数表中的指针指向的是什么呢？

我们转成汇编，我们发现call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象中去找的，而eax正好是虚函数表的第一个数0x00331082

 上图我们在F11，发现跳转到Base::Func1的地址，也就是说虚表指向jmp，jmp跳转到Base::Func1的地址

上图再F11，直接进入虚函数。 

我们通过底层知道虚表的指针存放在对象里 ，虚函数的地址要被放到虚函数表中

3.2 多态的原理 

那么派生类中这个表放了些什么呢？ 

 我们发现派生类继承基类，虚函数表不一样，派生类单独指向了一个新的虚表。这里我们做个假设，如果派生类不重写Func1，指向的虚表是一样的。这里我们重新开一个工作台，称第二个工作台

很明显假设失败，虚表的内容一样，但是虚表指针不一样

我们这里再次假设，相同类的对象，虚表指针一样。

看上面的图虚表指针相同

假设成立，所以说一个类中，对象不同，虚表指针相同。但是派生类又有自己的虚表指针，但是继承下来了未重写的虚函数地址。我们再次回到第一个工作台

我们再观察子类Derive的虚表func1发生了重写，导致只有继承的func2的地址0x00331398相等

  

 画个图更好的展示一下

3.2.1 动态绑定与静态绑定 

1. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体
行为，调用具体的函数，也称为动态多态。 

 怎么理解动态绑定呢？

我把虚表中的汇编代码拿过来，下面的过程就是在进行动态绑定 

 call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来
以后到对象的中取找的。

2. 静态绑定又称为编译时绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，
比如：函数重载，函数模板

3.3 拓展

虚函数表本质是函数指针数组

虚函数指针在对象，虚函数在代码段，虚表放在哪？

我们用VS验证一下。

我们这里要取到虚表的地址

int main()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);

	Base b;
	Derive d;

	// int/double/char//支持隐式类型转换
	// int和int*//表示强制类型转换   
	// 指针之间
	printf("Base虚表地址:%p\n", *((int*)&b));
	printf("Derive虚表地址:%p\n", *((int*)&d));
	printf("Base对象地址:%p\n", &b);
	printf("Derive对象地址:%p\n", &d);
	return 0;
}

虚表地址跟常量区很类似，虚函数表在常量区 

【拓展例题】 

class Base1 { public:  int _b1; };
class Base2 { public:  int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main() {
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}

p1与p2与p3什么关系

p1 == p3 ！= p2