多态概念及其触发条件

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

多态的构成条件：
1.必须通过基类的指针或者引用调用虚函数（即被virtual修饰的类成员函数称为虚函数）
2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

重写和协变

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

虚函数重写的两个例外：
1. 协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变
2. 析构函数的重写(基类与派生类析构函数的名字不同)
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor

override和final两个关键字

（考点1）

这里强调一下，重写重写的是实现。看以下这个场景：（考点）

class A
{
public:
	A()
	{}
	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()
{

	A* p = new B();
	p->test();
	return 0;
}

打印结果为B->1，说明调的是子类的func函数，但是缺省值用的却是父类，返回值，函数名，参数类型相同即构成重写，重写重写的是实现，壳子用的是父类的，写的内容自己控制

（考点2）

那为什么要把析构函数构成重写呢？看以下这个场景：（考点）


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

int main()
{
	Person* p = new Person;
	delete p;

	p = new Student;
	delete p; 
	return 0;
}

当我们用父类指针，指向子类对象时，期望析构的是子类对象，而不是父类对象。不构成重写的话，无论父类指针是指向子类对象还是父类对象，析构的都是父类对象，导致下面的 ptr 动态开辟的空间没有释放而内存泄漏

当我们给父类析构函数加上 virtual，让其构成重写后。同时注意这里析构玩~Student后还会析构继承父类，照应上面的构造先父后子，"析构先子后父"

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

动态绑定与静态绑定：

虚函数表及其位置

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，通过下面这个例子来看对象模型

（考点3）

这时候我们再反过来思考，为什么一定是父类的指针或者引用，而不能是父类对象？

首先我们可以看出，子类对象会先拷贝父类虚函数表，然后再对需要重写的虚函数进行地址修改。
假如我们把子类对象赋值给父类对象，那么子类对象的虚函数表要不要拷贝给父类？如果虚函数表不拷贝，那么还是调用父类的函数，没有构成多态。
如果拷贝了，那么父类对象的虚函数表存的是子类对象修改后的虚函数，如下图：此时我们无法再调用父类本身被重写的函数，因为无论我们传子类还是父类对象，调用的都是子类对象的函数，不能构成多态。
因此多态的条件，一定是父类的指针或者引用，这样可以避免像下面这样拷贝带来的错误。

虚表位置

class Person {
public:
	virtual	void BuyTicket() const { cout << "成人-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() const { cout << "学生-半价" << endl; }
};
int main()
{
	Person ps;
	Student st;
	int a = 0;
	printf("栈：%p\n\n", &a);
	static int b = 0;
	printf("静态区：%p\n\n", &b);
	int* p = new int;
	printf("堆：%p\n\n", p);
	const char* str = "hello world";
	printf("常量区：%p\n\n", str);
	printf("虚表1：%p\n", *((int*)&ps));
	printf("虚表2：%p\n", *((int*)&st));
	return 0;
}

虚表存放在哪里呢？首先排除堆，虚表由编译器生成，不会自己去动态申请空间。其次排除栈，同类型对象公用一张虚表，栈都是伴随栈帧走的，不能函数调用结束，栈帧销毁，虚表就销毁了吧。我们用打印的方式来看一下虚表是存在哪里的
看下面的代码和输出结果，我们可以发现，虚表是存在常量区的

多继承中的虚函数表

// 打印函数指针数组
typedef void(*FUNC_PTR) ();
void PrintVFT(FUNC_PTR* table)
{
	for (size_t i = 0; table[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, table[i]);
		FUNC_PTR f = table[i];
		f();//这个地址可以调用说明一定是函数
	}
	printf("\n");
}

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};
class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

int main()
{
	Derive d;
	int vft1 = *((int*)&d);
	Base2* ptr = &d;
	int vft2 = *((int*)ptr);
	printf("第一张虚表：\n");
	PrintVFT((FUNC_PTR*)vft1);
	printf("第二张虚表：\n");
	PrintVFT((FUNC_PTR*)vft2);
	return 0;
}

先看上面这段代码，首先d对象有几张虚表呢？看下面的监视窗口，很明显发现d对象有两张虚表，但是d对象自己的虚函数func3去哪里了，其实它在第一张虚表中，我们可以通过上面的代码打印观察出来，f()这个地址可以调用，说明它一定是函数。这里是可以认为是编译器的监视窗口故意隐藏了func3函数，也可以认为是它的一个小bug

可是细心一点发现，两张表中的func1地址不一样，它们不是都重写了func1函数吗？而且用父类指针调用会发现，它们调的是同一个函数，那么这里为什么地址不一样呢？

看下面这个场景

注意：这里你要调用的是派生类d对象的func1函数，this指针应该指向d对象，而这里的ptr1指针恰好指向d对象，不需要改动。而ptr2指向的却是Base2对象。调用d对象的func1函数要传d对象的this指针，而不是Base2对象的this指针。所以这里第二张表的地址其实是"虚地址"，多封装了几层是为了修正this指针