深度理解多态的底层实现

前言

首先先回顾一下上次的知识

一、多态的概念
多态(polymorphism)的概念：通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运⾏时多态(动态多态)，这⾥我们重点讲运⾏时多态，编译时多态(静态多态)和运⾏时多态(动态多态)。编译时多态(静态多态)主要就是我们前⾯讲的函数重载和函数模板，他们传不同类型的参数就可以调⽤不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的，我们把编译时⼀般归为静态，运⾏时归为动态。

运⾏时多态，具体点就是去完成某个⾏为(函数)，可以传不同的对象就会完成不同的⾏为，就达到多种形态。⽐如买票这个⾏为，当普通⼈买票时，是全价买票；学⽣买票时，是优惠买票(5折或75折)；军⼈买票时是优先买票。再⽐如，同样是动物叫的⼀个⾏为(函数)，传猫对象过去，就是”(>^ω<)喵“，传狗对象过去，就是"汪汪"。

二、多态的定义及实现

多态是⼀个继承关系的下的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。⽐如Student继承了Person。Person对象买票全价，Student对象优惠买票。

2.实现多态的重要条件：
必须是基类的指针或者引⽤调⽤虚函数
被调⽤的函数必须是虚函数，并且完成了虚函数重写/覆盖
多态必须存在于继承和派生类之间

一、多态的原理

1.1 虚函数表

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

在这里插入图片描述

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个_vftptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function,t代表table)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

下面我们看一看基类和派生类的虚表里面有什么？


class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
	
	virtual void Func1() 
	{
		cout << "Person::Func1()" << endl;
	}
	
	virtual void Func2() 
	{
		cout << "Person::Func2()" << endl;
	}
	
//protected:
	int _a = 0;
};
	
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
	
private:
	virtual void Func3()
	{
		//_b++;
		cout << "Student::Func3()" << endl;
	}
protected:
	int _b = 1;
};

void Func(Person& p)
{
	p.BuyTicket();
}
	
void test()
{
	Person ps1;
	Student st1;
}

int main()
{
	Person ps;
	Student st;
	st._a = 10;
	
	ps = st;
	Person* ptr = &st; //指向父类对象看到的父类的虚表
	Person& ref = st;  //指向子类对象看到的子类中父类的那一部分的虚表
		
	test();
	
	return 0;
}

在这里插入图片描述

派生类的虚表是怎么生成的呢？
只要是虚函数就会被放入虚表，可以认为派生类的虚表是先把父类的虚表先拷贝过来然后再把派生类重写过的虚函数在父类的虚表上进行覆盖，而没有被重写的虚函数就被继承了下来保持不变。
派生类自己的虚函数写在后面(VS环境下在监视窗口不会显示，得去内存窗口查看)；

总结一下派生类的虚表中包括：

先将基类中的虚表内容拷贝一份到派生类虚表中
如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共⽤同⼀张虚表，不同类型的对象各⾃有独⽴的虚表，所以基类和派⽣类有各⾃独⽴的虚表。
派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。
派⽣类中重写了基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函数地址。覆盖就是指虚表中虚函数
的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
派⽣类的虚函数表中包含，(1)基类的虚函数地址，(2)派⽣类重写的虚函数地址完成覆盖，(3)派⽣类自己的虚函数地址三个部分。
虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x00000000标记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x00000000标记，g++系列编译不会放) 。
虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函数的地址⼜存到了虚表中。
虚函数表存在哪的？ 这个问题严格说并没有标准答案C++标准并没有规定，我们写下⾯的代码可以对⽐验证⼀下。vs下是存在代码段(常量区)
从操作系统层面来说是代码段，而从语言的角度来说是叫常量区

那么虚表取的时候有涉及到大小端，判断大端小端怎么把低位的第一个字节取出来，如果低位的字节为1低位存低地址，int强转成char,取地址是int是四个字节，但是是指向第一个字节的开始，解引用看4个字节，类型决定看多大，强转成char就看第一个字节。具体看大小端博客讲解。

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
	
	virtual void Func1() 
	{
		cout << "Person::Func1()" << endl;
	}
	
	virtual void Func2() 
	{
		cout << "Person::Func2()" << endl;
	}
	
//protected:
	int _a = 0;
};
	
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
	
private:
	virtual void Func3()
	{
		//_b++;
		cout << "Student::Func3()" << endl;
	}
protected:
	int _b = 1;
};
	
void Func(Person& p)
{
	p.BuyTicket();
}


看一下虚表存在哪里

int main()
{
	Person ps;
	Student st;

	int a = 0;
	printf("栈：%p\n", &a);

	static int b = 0;
	printf("静态区：%p\n", &b);

	int* p = new int;
	printf("堆：%p\n", p);

	const char* str = "hello world";
	printf("常量区：%p\n", str);

	printf("虚表1：%p\n", *((int*)&ps));
	printf("虚表2：%p\n", *((int*)&st));


	return 0;
}

//宏定义
typedef void(*FUNC_PTR) ();

 打印函数指针数组   看一看Func到底在不在派生类虚函数表中
// void PrintVFT(FUNC_PTR table[])
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");
}

int main()
{
	Person ps;
	Student st;

	int vft1 = *((int*)&ps);
	PrintVFT((FUNC_PTR*)vft1);

	int vft2 = *((int*)&st);
	PrintVFT((FUNC_PTR*)vft2);

	return 0;
}

1.2 静态绑定与动态绑定

静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

编译时多态通过不同参数匹配实现调用不同的函数，函数模板编译时根据实际调用，对函数模板进行实例化出三个函数，通过重载去匹配对应的函数。这两个都是在编译时进行匹配和实例化
编译时通过参数确定的，达到不同的参数调用不同的函数，形成多种形态
在语法层完成某个行为就是调某个函数，之前都是通过参数匹配

满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到指定对象的中虚表去找的。不满足多态的函数调用时编译时确认好的。

运行起来到指定对象的虚表里去找对应的地址call进行调用

 多态
 静态(编译时)的多态，函数重载，函数模板
 动态(运行时)的多态， 通过继承，虚函数重写实现多态。核心机制是虚函数表和虚函数表指针
int main()
{
	int i = 1;
	double d = 1.1;
	cout << i << endl;
	cout << d << endl;

	Person ps;
	Person* ptr = &ps;

	ps.BuyTicket();
	ptr->BuyTicket();

	return 0;
}

1.3 多继承中的虚函数表

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;
};

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
		cout << endl;
}
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
在这里插入图片描述

派生类没必要单独产生虚表，因为派生类继承父类，派生类里面的父类就包含虚表。这样就够了就可以实现多态。
多态是父类的指针或引用，指向父类对象时找的时父类的虚函数，指向子类时切片切出子类当中父类的那一部分，去这部分找出被子类重写的虚函数覆盖的那部分即可。

这个虚表也可以算是子类自己的，子类中的父类也算是子类的成员，并且虚表也不是和父类共用的是把父类的拷贝下来自己再进行覆盖等等。

这里还有一个为什么重写func1，但Base1和Base2的虚表中Func1的地址不一样？
这里就涉及到this指针，ecx，call eax地址，jmp 反汇编
因为Derive和Base1起始地址一样，因为Derive先继承的Base1，而Base2调用Func1的时候需要sub ecx，8；找到func1的实际内存地址进行调用；

地址也可以一样，再提前修正一步
在这里插入图片描述

二、注意事项

1 、虚函数重写中参数列表相同这里注意有坑

注意虚函数重写的坑(参数列表)

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();
	因为子类继承父类的成员函数test, 只是子类可以访问test函数，
	但是这个test函数本身还是父类对象的，
	这个时候这个test函数中的this指针依旧还是父类的
	是A*调用test（）中的func（）;
	return 0;
	
	/*不构成多态就看它的类型，构成多态就看其指向的对象*/
}

B能调用test()是因为继承，  this->func()
                       A*
 p->test(); 传一个B*给A*，切片，看的是A对象，调用的是A的func  B*转A*  例如：B bb; A* p = &bb;
 本质是让A*指向了B的对象

子类继承父类的时候，并不会把父类的成员变量/函数拷贝下来，两个类还是独立的只是说在生成一个B的对象的时候里面由两部分构成，一部分父类的，一部分子类的；

隐藏：
成员函数名相同且在两个不同的作用域就构成隐藏
会先在子类里面找，找到了子类就对父类形成隐藏
( 如果需要直接调用父类的需要加上域作用限定符指定访问；)
找不到就会去父类找；

因为隐藏的问题，在继承体系下有一个隐藏的说法，就是子类和父类同名函数，子类会隐藏父类，
所以直接用子类指针找，访问的是子类的，如果子类没有，那么子类就会继承父类的，去父类哪里寻找访问。

2、虚析构函数

为什么基类中的析构函数建议设计为虚函数？
因为多态的原因析构函数要统一名字。
某种情况下派生类可以不加virtual，也是为了这里析构函数。
如果要设计一个类，这个类想要被继承，就把基类的析构函数加上virtual写成虚函数；

class A
{
	public :
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};
class B : public A {
public:
	~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};
 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能
构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。
void func(A* ptr)
{
	//ptr->f();
	delete ptr;
	// ptr->调用各自的析构函数() //不构成多态时，就是普通对象会根据当前的类型调用两次A的析构函数
	// ptr->destructor()      //构成多态
	// operator delete(ptr)
}
int main()
{
	//这种情况没问题
	A* aa1;
	B* bb1;
	//这个OK
	//A* p1 = new A;
	//B* p2 = new B;
	//delete p1;
	//delete p2;

    这就情况就过不了
	func(new A);
	func(new B);
	//
	这个同理
	A* p1 = new A;
	A* p2 = new B;
	delete p1;
	delete p2;
	
	return 0;
}

析构函数的重写:
基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派⽣类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统⼀处理成destructor，所以只要基类的析构函数加了vialtual修饰，派⽣类的析构函数就构成重写。

下⾯的代码我们可以看到，如果~A()，不加virtual，那么delete p2时只调⽤的A的析构函数，没有调⽤B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。(使用父类指针或者引用去操作子类对象，只会调用父类中的析构函数，并不会调用子类的析构函数)。

涉及到一个知识点：
派生类的析构函数不需要显示调用父类的析构函数，会自动调用