虚函数表与虚函数指针关系详解

虚函数表一个类一个吗?
1. 虚函数表属于类，类的所有对象共享这个类的虚函数表。
2. 不同对象虚函数表是一样的（虚函数表的第一个函数地址相同）；
3. 每个对象内部都保存一个指向该类虚函数表的指针vptr，每个对象的vptr的存放地址都不一样，但是都指向同一虚函数表。
如果一个类中含有虚函数，那么其虚函数表和虚函数指针的归属和存储位置如下所示

当一个对象调用了虚函数，实际的被调用函数通过下面的步骤确定：找到对象的 vptr 指向的 vtbl，然后在 vtbl 中寻找合适的函数指针。

虚函数表与虚函数指针示例：

class Base1{
public:
	Base1(int i){m_i1=i;}
	~Base1(){ cout << "Base1 deconstruct" << endl;}
	virtual void f1()
	{
		cout << "Base1::f1()" << endl;
	}
	virtual void g1()
	{
		cout << "Base1::g1()" << endl;
	}
private:
	int m_i1;
};

打印此虚函数表：（采用函数指针遍历）

   Base1 base1(1);

cout<<"Base1大小"<<sizeof(base1)<<endl;
long *p0 = (long *)(*(long*)&base1);
PrintVTable(p0); 
cout<<endl;
cout<<endl;
cout<<endl;
Base1 base11(2);
cout<<"Base11大小"<<sizeof(base11)<<endl;
long *p1 = (long *)(*(long*)&base11);
PrintVTable(p1); 

结果：

结论：一个类的所有对象公用一个虚函数表（虚函数地址一样）。

单继承查看虚函数表与虚函数指针

class Base3:public Base1{//单继承
public:
	// Test1(int d1, int d2) :Test(d2) { data1 = d1; data2 = d2; }
	Base3(int i1,int i2):Base1(i2){m_i3=i1;}
	~Base3(){ cout << "Base3 deconstruct" << endl;}
	virtual void f1()//覆盖
	{
		cout << "Base3::f1()" << endl;
	}
	virtual void f3()//附加虚函数
	{
		cout << "Base3::f3()" << endl;
	}
	virtual void g3()//附加虚函数
	{
		cout << "Base3::g3()" << endl;
	}
private:
	int m_i3;
};

打印虚函数表：

Base3 base3(1,2);
cout<<"Base3大小"<<sizeof(base3)<<endl;
long *p2 = (long *)(*(long*)&base3);
PrintVTable(p2); 

结果：

结论：派生类继承了基类的虚函数表，在base3继承了base1，同时覆写了f1，在虚函数表base3中，f1的地址以base3覆盖，同时自己另外自定义的虚函数f3和g3的地址加入虚函数表的后面。

多继承：

class Base2{
public:
	Base2(int i){m_i2=i;}
	~Base2(){ cout << "Base2 deconstruct" << endl;}
	virtual void f2()
	{
		cout << "Base2::f2()" << endl;
	}
	virtual void g2()
	{
		cout << "Base2::g2()" << endl;
	}
private:
	int m_i2;
};
class Base4:public Base1,public Base2{//多继承
public:
	Base4(int i1,int i2,int i3):Base1(i2),Base2(i3){m_i4=i1;}
	~Base4(){ cout << "Base4 deconstruct" << endl;}
	virtual void f1()//覆盖基类1
	{
		cout << "Base4::f1()" << endl;
	}
	virtual void g2()//覆盖基类2
	{
		cout << "Base4::g2()" << endl;
	}
	virtual void f4()//附加虚函数
	{
		cout << "Base4::f4()" << endl;
	}
	virtual void g4()//附加虚函数
	{
		cout << "Base4::g4()" << endl;
	}
private:
	int m_i4;
};

打印此虚函数表：

      Base4 base4(1,2,3);
cout<<"Base3大小"<<sizeof(base4)<<endl;
long *p3 = (long *)(*(long*)&base4);
PrintVTable(p3); 

结果：

结论：
多继承情况下，派生类中有多个虚函数表，虚函数的排列方式和继承的顺序一致。派生类重写函数将会覆盖所有虚函数表的同名内容，派生类自定义新的虚函数将会在第一个类的虚函数表的后面进行扩充。

附加源码：

class Base1{
public:
	Base1(int i){m_i1=i;}
	~Base1(){ cout << "Base1 deconstruct" << endl;}
	virtual void f1()
	{
		cout << "Base1::f1()" << endl;
	}
	virtual void g1()
	{
		cout << "Base1::g1()" << endl;
	}
private:
	int m_i1;
};
class Base2{
public:
	Base2(int i){m_i2=i;}
	~Base2(){ cout << "Base2 deconstruct" << endl;}
	virtual void f2()
	{
		cout << "Base2::f2()" << endl;
	}
	virtual void g2()
	{
		cout << "Base2::g2()" << endl;
	}
private:
	int m_i2;
};
class Base3:public Base1{//单继承
public:
	// Test1(int d1, int d2) :Test(d2) { data1 = d1; data2 = d2; }
	Base3(int i1,int i2):Base1(i2){m_i3=i1;}
	~Base3(){ cout << "Base3 deconstruct" << endl;}
	virtual void f1()//覆盖
	{
		cout << "Base3::f1()" << endl;
	}
	virtual void f3()//附加虚函数
	{
		cout << "Base3::f3()" << endl;
	}
	virtual void g3()//附加虚函数
	{
		cout << "Base3::g3()" << endl;
	}
private:
	int m_i3;
};
class Base4:public Base1,public Base2{//多继承
public:
	Base4(int i1,int i2,int i3):Base1(i2),Base2(i3){m_i4=i1;}
	~Base4(){ cout << "Base4 deconstruct" << endl;}
	virtual void f1()//覆盖基类1
	{
		cout << "Base4::f1()" << endl;
	}
	virtual void g2()//覆盖基类2
	{
		cout << "Base4::g2()" << endl;
	}
	virtual void f4()//附加虚函数
	{
		cout << "Base4::f4()" << endl;
	}
	virtual void g4()//附加虚函数
	{
		cout << "Base4::g4()" << endl;
	}
private:
	int m_i4;
};

typedef void(*FUNC)();        //重定义函数指针，指向函数的指针
void PrintVTable(long* vTable)  //打印虚函数表
{
	if (vTable == NULL)
	{
		return;
	}
	cout << "vtbl:" << vTable << endl;
	int  i = 0;
	for (; vTable[i] != 0; ++i)
	{
		printf("function : %d :0X%x->", i, vTable[i]);
		FUNC f = (FUNC)vTable[i];
		f();         //访问虚函数
	}
	cout << endl;
}

int main()
{
	Base1 base1(1);
	cout<<"Base1大小"<<sizeof(base1)<<endl;
	long *p0 = (long *)(*(long*)&base1);
	PrintVTable(p0); 
	cout<<endl;
	cout<<endl;
	cout<<endl;
	Base1 base11(2);
	cout<<"Base11大小"<<sizeof(base11)<<endl;
	long *p1 = (long *)(*(long*)&base11);
	PrintVTable(p1); 
	
	
	cout<<endl;
	cout<<endl;
	cout<<endl;
	Base3 base3(1,2);
	cout<<"Base3大小"<<sizeof(base3)<<endl;
	long *p2 = (long *)(*(long*)&base3);
	PrintVTable(p2); 
	
	
	cout<<endl;
	cout<<endl;
	cout<<endl;
	Base4 base4(1,2,3);
	cout<<"Base3大小"<<sizeof(base4)<<endl;
	long *p3 = (long *)(*(long*)&base4);
	PrintVTable(p3); 
	
	system("pause");
	return 0;
	
}