C++多态的原理

讲解虚函数原理之前我们先做道题回顾一下多态的内容：

cpp 复制代码

//以下程序输出结果是什么:
// A: A->0    B: B->1   C: A->1   D: B->0   E: 编译出错    F: 以上都不正确
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;
}

答案是：B。

讲解：

这里这道题目其实就是单纯为了考试存在的，如果我们实际工作中写出这种代码，被骂司马都算好的了。所以大家千万不要学习这种纱布代码。

一、虚函数的原理

首先我们来看看这到题：

cpp 复制代码

// sizeof(Base)是多少？
class Base
{
    public:
    virtual void Func1()
    {
        cout << "Func1()" << endl;
    }
    
    private:
    int _b = 1;
};

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

cpp 复制代码

// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
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;
};

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

通过观察和测试，我们发现了以下几点问题：

派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员（虚表指针也是存在继承下来中父类部分的），另一部分是自己的成员。
基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。（这个不同平台下会有不同，就好比如使用g++编译的时候，虚表末尾就不会存空指针）
总结一下派生类的虚表生成：

a.先将基类中的虚表内容拷贝一份到派生类虚表中

b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数

c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
这里还有一个大家很容易混淆的问题：虚函数存在哪的？虚表存在哪的？答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多人都是这样深以为然的。注意：虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是它们的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在常量区的，Linux g++下也是存在常量区的。

我们可以使用下面这段代码粗略的去验证：

cpp 复制代码

#include <iostream>
using namespace std;

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

int main()
{
	Base b;
	Derive d;

	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* p3 = &b;
	Derive* p4 = &d;

	printf("Base虚表地址:%p\n", *(int*)p3);
	printf("Derive虚表地址:%p\n", *(int*)p4);

	return 0;
}

我们可以看到虚表地址是距离常量区更近的，所以我们估计虚表（虚函数表）是存在常量区的。

那么为什么可以这样去验证呢？首先，我们知道在对象中的前四个字节存储的就是虚函数表的地址，所以我们只需要打印对象的前4个字节就可以获得虚函数表的地址。

那么这里的方法就是先将对象通过取对象地址转换成指针，然后将类指针转换成int类型的指针，然后对int类型指针进行解引用就可以获得对象前四个字节的内容。

这里顺便给大家一个打印虚函数表的方法：

cpp 复制代码

#include <iostream>
using namespace std;


typedef void(*VF_PTR)();

// 打印虚表，本质打印指针(虚函数指针)数组
//因为有些平台虚表的末尾是不存空指针的，所以就要用n来指定虚函数个数
//void PrintVFT(VF_PTR vft[], int n)

//这个写法和下面的写法并无不同
//void PrintVFT(VF_PTR vft[])
void PrintVFT(VF_PTR* vft)
{
	for (size_t i = 0; vft[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, vft[i]);

		VF_PTR f = vft[i];
		f();
		//(*f)();
	}
	cout << endl << endl;
}
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;
	}
	virtual void Func3()
	{
		cout << "Derive::Func3()" << endl;
	}
private:
	int _d = 2;
};

int main()
{
	Derive d;
	
	PrintVFT((VF_PTR*)(*((int*)&d)));
	
	return 0;
}

结果我们可以看到是打印完全了的。这里我就不对这个代码做过多解释了，主要就是指针的内容。

二、多态的原理

这里我们使用下面的代码给大家讲解：

cpp 复制代码

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

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

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

int main()
{
    Person Mike;//正常成人
    Func(Mike);
    
    Student Johnson;//学生
    Func(Johnson);
    
    return 0;
}

总结一下多态的原理其实主要就是基于这几个方面：

基于继承体系
虚函数（虚函数重写）和虚函数表
派生类对象可以赋值给基类对象/基类引用/基类指针，也就是切片，或者说向上转换。