波奇学C++:多态知识点

多态中函数的重写（基类指针访问派生类函数），只重写函数的实现，而不重写声明。

class Person
{
public:
	 virtual void fun(int i = 0)
	{
		cout << "Person"<<" "<
	}
};
class Student:public Person
{
public:
	 virtual void fun(int i = 1)
	{
		cout << "student" <<" "<
	}
};
int main()
{
	Person p;
	Student st;
	Person* pp = &st;
	pp->fun();
 
	return 0;
}

结果是 student 0 原因在于重写时只重写函数的实现，就是说相当于Person的fun的声明和Student的函数实现的拼在一起所以缺省值是0。

为什么多态调用（重写）只能用父类的指针和引用，不能子类指针或者引用，不能是父类对象？

如果是子类指针或者引用就不是多态调用了只是单存子类对父类的重定义，隐藏函数。

上一篇文章提到的，多态的本质就是基类和派生类的虚表中保存的虚函数地址被覆盖了，多态调用意味着访问的必须是子类的虚表而不是父类的。

子类对象直接赋值父类不会拷贝虚表虚函数的地址

上图为赋值前，下图为赋值后，如图他们的__vfptr始终不同，所以父类对象必然无法访问子类对象的虚函数的地址。

为什么指针和引用可以？

父类型指针表示它范围的范围是父类，所以它指向子对象时，本质上依然说访问子类的父类部分，虚表依然是子类的虚表。

引用同理，相当于切割出子类中父类的部分。本质上依然是子类的虚表。

为什么父类指针可以指向子类对象？可以指向意味着结构相似，原因在于，继承相当于把父对象一整个拷贝放在子对象中，结构相似也是向上转换的基础

虚表的存储在代码段

证明思路：输出各个区的地址和虚表的地址，进行比较，字节相差较少说明在哪个区。

int main()
{
	Person p;
	Student st;
	int a = 1;
	printf("栈上：%x\n", &a);
	int* b = new int;
	printf("堆上：%x\n", b);
	static int c = 0;
	printf("静态区：%x\n", &c);
	const char* d = "abcde";
	printf("代码段：%x\n", d);
	printf("虚表1：%x\n", *((int*)&p));
	printf("虚表2：%x\n", *((int*)&st));
	return 0;
 
}

注意打印对象是打印对象的成员变量的值，这里是因为__vptr内置变量（保存虚表地址）的在成员变量首位，所以可以打印出来，同时int* 是只取虚表的地址后四个字节（小端机），%x也是只打印地址的后4位字节。

通过比较可发现，虚表和代码段的位置更近，所以虚表在代码段中。

派生类新的虚函数保存在虚表中，原有虚函数的地址的下面

class Person
{
public:
	 virtual void fun(int i = 0)
	{
		cout << "Person"<<" "<
	}
	 int _a;
};
class Student:public Person
{
public:
	 virtual void fun(int i = 1)
	{
		cout << "student" <<" "<
	}
	 virtual void fun1()
	 {
		 cout << "new virtual fun1()";
	 }
	 int _b;
};

fun1()是Student的虚函数，fun1保存在子函数的虚表中

证明：虚表保存函数指针地址，虚表可以看成指针数组，所以我们可以把虚表的函数指针打印出来。

typedef void(*FUNC_PTR) ();//重定义函数指针类型
//形参是数组，实参为数组指针
void PrintVFT(FUNC_PTR table[])
{
    //vs会在虚表末尾保存一个空指针，所以循环到nullptr为止
	for (size_t i = 0; table[i] != nullptr; i++)
	{
		printf("[%d]:%p\n", i, table[i]);
	}
}
int main()
{
	Person ps;
	Student st;
	int vft1 = *((int*)&ps);
//86位机器地址是32位转换成int*
	PrintVFT((FUNC_PTR*)vft1);
	int vft2 = *((int*)&st);
	PrintVFT((FUNC_PTR*)vft2);
	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;
	cout << sizeof(d) << endl;
	int vft1 = *((int*)&d);
	Base2* ptr = &d;
	int vft2 = *((int*)ptr);
	PrintVFT((FUNC_PTR*)vft1);
	PrintVFT((FUNC_PTR*)vft2);
	return 0;
 
}

下面代码的Derive继承了Base1和Base2，其中两个fun1()都被继承了。

打印结果

 为什么是20？

 因为是一整个对象继承，所以会存在两个虚表，base1，base2虚表指针+int变量 8+8+4=20

由上面的结果图可知fun1在两个虚表中被重写，且都调用了同一个函数。但是地址却不一样，

实际上调用虚表2的fun()的地址，会改变指针位置和虚表1fun()指针相同，再调用函数。

反汇编证明

b1,b2指针分别调用fun1(),反汇编，call指令进入func1函数，此时

注意此处fun1()的地址是0C92840h

调用base2的fun1虚表地址，此时地址是0C94670h

进入call指令，ecx-8,再jump向0C91244h地址最后到base1虚表的地址。

 

 简单来说指向base2部分的指针，先指向base1的，再调用指针1保存的重写函数的地址。