本文深入探讨了C++中的虚函数表（V-Table）实现机制，通过实例展示了如何通过对象实例获取虚函数表，并解释了不同继承情况下（单继承、多继承，有覆盖、无覆盖）虚函数表的结构。通过对虚函数表的理解，有助于更好地掌握C++的多态机制。
【C++学习】C++ 虚函数表解析
转载至：https://coolshell.cn/articles/12165.html
这篇文章讲解的很透彻，我转载过来对里面的示例进行了一点完善，以便以后学习。
C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
关于虚函数的使用方法，我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中，我只想从虚函数的实现机制上面为大家 一个清晰的剖析。
当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，没有详细的说明，没有比较，没有举一反三。不利于学习和阅读，所以这是我想写下这篇文章的原因。也希望大家多给我提意见。
言归正传，让我们一起进入虚函数的世界。
虚函数表
对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。
这里我们着重看一下这张虚函数表。C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。
听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。 没关系，下面就是实际的例子，相信聪明的你一看就明白了。
假设我们有这样的一个类：
class Base
{
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
virtual void h() { cout << "Base::h" << endl; }
int data1;
int data2;
private:
}; 按照上面的说法，我们可以通过Base的实例来得到虚函数表。 下面是实际例程：
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
virtual void h() { cout << "Base::h" << endl; }
int data1;
int data2;
private:
};
typedef void(*Fun)(void);
int main()
{
Base b;
b.data1 = 12345;
b.data2 = 54321;
Fun pFun = NULL;
cout << "虚函数表地址：" << (int*)(&b) << endl;
cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;
// Invoke the first virtual function
pFun = (Fun)*((int*)*(int*)(&b));
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&b)) + 1) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&b)) + 2) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&b)) + 3) );
if( !pFun ){
cout << "pFun is NULL" << endl;
}else{
cout << "pFun addr is " << pFun << endl;
}
cout << "data1 : " << *((int *)(&b) + 1) << endl;
cout << "data2 : " << *((int *)(&b) + 2) << endl;
return 0;
}在Win7 + VS2012 上运行结果如下:
在Centos7 + GCC4.8.5上运行结果如下：
通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，包括后面的Base::g()和Base::h()，这在上面的程序中得到了验证（把int* 强制转成了函数指针），为了进一步验证，我们也尝试去访问类中的其他成员变量，也是可以行的。
这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：
注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在Win7+VS2012下，这个值是NULL。而在Centos 7.10 GCC 4.8.5下，这个值如果是1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。（这个程序打印有点出入）
下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。
一般继承（无虚函数覆盖）
下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：
请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：
对于实例：Derive d; 的虚函数表如下：
我们可以看到下面几点：
1）虚函数按照其声明顺序放于表中。
2）父类的虚函数在子类的虚函数前面。
我们还是来一段简单的程序测试下：
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
virtual void h() { cout << "Base::h" << endl; }
int data1;
int data2;
private:
};
class Derive : public Base
{
public:
virtual void f1() { cout << "Derive::f1" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
virtual void h1() { cout << "Derive::h1" << endl; }
int data3;
int data4;
private:
};
typedef void(*Fun)(void);
int main()
{
Derive d;
d.data1 = 12345;
d.data2 = 54321;
d.data3 = 23456;
d.data4 = 66666;
Fun pFun = NULL;
cout << "虚函数表地址：" << (int*)(&d) << endl;
cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&d) << endl;
// Invoke the first virtual function
pFun = (Fun)*((int*)*(int*)(&d));
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 1) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 2) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 3) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 4) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 5) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 6) );
if( !pFun ){
cout << "pFun is NULL" << endl;
}else{
cout << "pFun addr is " << pFun << endl;
}
cout << "data1 : " << *((int *)(&d) + 1) << endl;
cout << "data2 : " << *((int *)(&d) + 2) << endl;
cout << "data3 : " << *((int *)(&d) + 3) << endl;
cout << "data4 : " << *((int *)(&d) + 4) << endl;
return 0;
}在Win7 + VS2012 上运行结果如下:
在Centos7 + GCC4.8.5上运行结果如下：
可见，两个平台的运行结果都很好的验证了我们上面的结论。
一般继承（有虚函数覆盖）
覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。
为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：
我们从表中可以看到下面几点，
1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。
2）没有被覆盖的函数依旧。
我们同样还是来一段简单的程序测试下：
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
virtual void h() { cout << "Base::h" << endl; }
int data1;
int data2;
private:
};
class Derive : public Base
{
public:
void f() { cout << "Derive::f" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
virtual void h1() { cout << "Derive::h1" << endl; }
int data3;
int data4;
private:
};
typedef void(*Fun)(void);
int main()
{
Derive d;
d.data1 = 12345;
d.data2 = 54321;
d.data3 = 23456;
d.data4 = 66666;
Fun pFun = NULL;
cout << "虚函数表地址：" << (int*)(&d) << endl;
cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&d) << endl;
// Invoke the first virtual function
pFun = (Fun)*((int*)*(int*)(&d));
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 1) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 2) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 3) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 4) );
pFun();
pFun = (Fun)( *( ((int*)*(int*)(&d)) + 5) );
if( !pFun ){
cout << "pFun is NULL" << endl;
}else{
cout << "pFun addr is " << pFun << endl;
}
cout << "data1 : " << *((int *)(&d) + 1) << endl;
cout << "data2 : " << *((int *)(&d) + 2) << endl;
cout << "data3 : " << *((int *)(&d) + 3) << endl;
cout << "data4 : " << *((int *)(&d) + 4) << endl;
return 0;
}在Win7 + VS2012 上运行结果如下:
在Centos7 + GCC4.8.5上运行结果如下：
同样的两个平台的上的运行结果都很好的验证了我们上面的结论。
现在我们再来看看下面一个简单的程序：
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
virtual void h() { cout << "Base::h" << endl; }
int data1;
int data2;
private:
};
class Derive : public Base
{
public:
void f() { cout << "Derive::f" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
virtual void h1() { cout << "Derive::h1" << endl; }
int data3;
int data4;
private:
};
typedef void(*Fun)(void);
int main()
{
Fun pFun = NULL;
Base *b = new Derive();
b->f();
pFun = (Fun)*((int*)*(int*)(b));
pFun();
return 0;
}在Win7 + VS2012 上运行结果如下:
在Centos7 + GCC4.8.5上运行结果如下：
从上面两个结果来看，由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这其实就实现了多态。
多重继承（无虚函数覆盖）
下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。
对于子类实例中的虚函数表，是下面这个样子：
我们可以看到：
1） 每个父类都有自己的虚表。
2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）
我们同样还是来一段简单的程序测试下：
#include <iostream>
using namespace std;
class Base1
{
public:
virtual void f() { cout << "Base1::f" << endl; }
virtual void g() { cout << "Base1::g" << endl; }
virtual void h() { cout << "Base1::h" << endl; }
private:
};
class Base2
{
public:
virtual void f() { cout << "Base2::f" << endl; }
virtual void g() { cout << "Base2::g" << endl; }
virtual void h() { cout << "Base2::h" << endl; }
private:
};
class Base3
{
public:
virtual void f() { cout << "Base3::f" << endl; }
virtual void g() { cout << "Base3::g" << endl; }
virtual void h() { cout << "Base3::h" << endl; }
private:
};
class Derive : public Base1 , public Base2 , public Base3
{
public:
virtual void f1() { cout << "Derive::f1" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
virtual void h1() { cout << "Derive::h1" << endl; }
int data1;
int data2;
private:
};
typedef void(*Fun)(void);
int main()
{
Derive d;
int count = 0;
Fun pFun = NULL;
int *ptr = NULL;
d.data1 = 11111;
d.data2 = 22222;
cout << "第一个虚函数表地址：" << (int*)(&d) << endl;
cout << "第二个虚函数表地址：" << (int*)(&d) + 1 << endl;
cout << "第三个虚函数表地址：" << (int*)(&d) + 2 << endl;
// Invoke the first virtual function
cout << "Invoke the all the funcitons in the first virtual function table" << endl;
ptr = ((int*)*(int*)(&d));
pFun = (Fun)*(ptr);
count = 6;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
// Invoke the second virtual function
cout << "Invoke the all the funcitons in the second virtual function table" << endl;
ptr = (int*)*((int *)(&d) + 1);
pFun = (Fun)*(ptr);
count = 3;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
// Invoke the third virtual function
cout << "Invoke the all the funcitons in the third virtual function table" << endl;
ptr = (int*)*((int *)(&d) + 2);
pFun = (Fun)*(ptr);
count = 3;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
cout << "data1 : " << *((int *)(&d) + 3) << endl;
cout << "data1 : " << *((int *)(&d) + 4) << endl;
return 0;
}在Win7 + VS2012 上运行结果如下:
在Centos7 + GCC4.8.5上运行结果如下：
上面的运行结果，完美的验证了上面的结论。但是会有个问题，因为我们的基类中都没有考虑成员变量，如果考虑成员变量会是怎么个情况呢？
就我个人的理解，这个时候Derive的对象内存结构应该如下图所示：
我们修改下上面的测试程序，来简单的验证下：
#include <iostream>
using namespace std;
class Base1
{
public:
virtual void f() { cout << "Base1::f" << endl; }
virtual void g() { cout << "Base1::g" << endl; }
virtual void h() { cout << "Base1::h" << endl; }
int data1;
int data2;
private:
};
class Base2
{
public:
virtual void f() { cout << "Base2::f" << endl; }
virtual void g() { cout << "Base2::g" << endl; }
virtual void h() { cout << "Base2::h" << endl; }
int data3;
int data4;
private:
};
class Base3
{
public:
virtual void f() { cout << "Base3::f" << endl; }
virtual void g() { cout << "Base3::g" << endl; }
virtual void h() { cout << "Base3::h" << endl; }
int data5;
int data6;
private:
};
class Derive : public Base1 , public Base2 , public Base3
{
public:
virtual void f1() { cout << "Derive::f1" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
virtual void h1() { cout << "Derive::h1" << endl; }
int data7;
int data8;
private:
};
typedef void(*Fun)(void);
int main()
{
Derive d;
int count = 0;
Fun pFun = NULL;
int *ptr = NULL;
d.data1 = 11111;
d.data2 = 22222;
d.data3 = 33333;
d.data4 = 44444;
d.data5 = 55555;
d.data6 = 66666;
d.data7 = 77777;
d.data8 = 88888;
cout << "第一个虚函数表地址：" << (int*)(&d) << endl;
// 后面要跳过两个Base1的数据成员才是第二个虚函数表地址
cout << "第二个虚函数表地址：" << (int*)(&d) + 3 << endl;
// 后面要跳过两个Base2的数据成员才是第二个虚函数表地址
cout << "第三个虚函数表地址：" << (int*)(&d) + 6 << endl;
// Invoke the first virtual function
cout << "Invoke the all the funcitons in the first virtual function table" << endl;
ptr = ((int*)*(int*)(&d));
pFun = (Fun)*(ptr);
count = 6;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
cout << "data1 : " << *((int *)(&d) + 1) << endl;
cout << "data2 : " << *((int *)(&d) + 2) << endl;
// Invoke the second virtual function
cout << "Invoke the all the funcitons in the second virtual function table" << endl;
ptr = (int*)*((int *)(&d) + 3);
pFun = (Fun)*(ptr);
count = 3;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
cout << "data3 : " << *((int *)(&d) + 4) << endl;
cout << "data4 : " << *((int *)(&d) + 5) << endl;
// Invoke the third virtual function
cout << "Invoke the all the funcitons in the third virtual function table" << endl;
ptr = (int*)*((int *)(&d) + 6);
pFun = (Fun)*(ptr);
count = 3;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
cout << "data5 : " << *((int *)(&d) + 7) << endl;
cout << "data6 : " << *((int *)(&d) + 8) << endl;
cout << "data7 : " << *((int *)(&d) + 3) << endl;
cout << "data8 : " << *((int *)(&d) + 4) << endl;
return 0;
}在Win7 + VS2012 上运行结果如下:
在Centos7 + GCC4.8.5上运行结果如下：
从上面两个结果来看，很好的验证了我的理解。这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。
多重继承（有虚函数覆盖）
下面我们再来看看，如果发生虚函数覆盖的情况。
下图中，我们在子类中覆盖了父类的f()函数。
下面是对于子类实例中的虚函数表的图：
我们同样还是来一段简单的程序测试下：
#include <iostream>
using namespace std;
class Base1
{
public:
virtual void f() { cout << "Base1::f" << endl; }
virtual void g() { cout << "Base1::g" << endl; }
virtual void h() { cout << "Base1::h" << endl; }
int data1;
int data2;
private:
};
class Base2
{
public:
virtual void f() { cout << "Base2::f" << endl; }
virtual void g() { cout << "Base2::g" << endl; }
virtual void h() { cout << "Base2::h" << endl; }
int data3;
int data4;
private:
};
class Base3
{
public:
virtual void f() { cout << "Base3::f" << endl; }
virtual void g() { cout << "Base3::g" << endl; }
virtual void h() { cout << "Base3::h" << endl; }
int data5;
int data6;
private:
};
class Derive : public Base1 , public Base2 , public Base3
{
public:
void f() { cout << "Derive::f" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
virtual void h1() { cout << "Derive::h1" << endl; }
int data7;
int data8;
private:
};
typedef void(*Fun)(void);
int main()
{
Derive d;
int count = 0;
Fun pFun = NULL;
int *ptr = NULL;
d.data1 = 11111;
d.data2 = 22222;
d.data3 = 33333;
d.data4 = 44444;
d.data5 = 55555;
d.data6 = 66666;
d.data7 = 77777;
d.data8 = 88888;
cout << "第一个虚函数表地址：" << (int*)(&d) << endl;
// 后面要跳过两个Base1的数据成员才是第二个虚函数表地址
cout << "第二个虚函数表地址：" << (int*)(&d) + 3 << endl;
// 后面要跳过两个Base2的数据成员才是第二个虚函数表地址
cout << "第三个虚函数表地址：" << (int*)(&d) + 6 << endl;
// Invoke the first virtual function
cout << "Invoke the all the funcitons in the first virtual function table" << endl;
ptr = ((int*)*(int*)(&d));
pFun = (Fun)*(ptr);
count = 5;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
cout << "data1 : " << *((int *)(&d) + 1) << endl;
cout << "data2 : " << *((int *)(&d) + 2) << endl;
// Invoke the second virtual function
cout << "Invoke the all the funcitons in the second virtual function table" << endl;
ptr = (int*)*((int *)(&d) + 3);
pFun = (Fun)*(ptr);
count = 3;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
cout << "data3 : " << *((int *)(&d) + 4) << endl;
cout << "data4 : " << *((int *)(&d) + 5) << endl;
// Invoke the third virtual function
cout << "Invoke the all the funcitons in the third virtual function table" << endl;
ptr = (int*)*((int *)(&d) + 6);
pFun = (Fun)*(ptr);
count = 3;
while( count > 0 && pFun ){
pFun();
ptr += 1;
count--;
pFun = (Fun)*(ptr);
}
cout << endl;
cout << "data5 : " << *((int *)(&d) + 7) << endl;
cout << "data6 : " << *((int *)(&d) + 8) << endl;
cout << "data7 : " << *((int *)(&d) + 3) << endl;
cout << "data8 : " << *((int *)(&d) + 4) << endl;
return 0;
}在Win7 + VS2012 上运行结果如下:
在Centos7 + GCC4.8.5上运行结果如下：
由上面的运行结果我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：
#include <iostream>
using namespace std;
class Base1
{
public:
virtual void f() { cout << "Base1::f" << endl; }
virtual void g() { cout << "Base1::g" << endl; }
virtual void h() { cout << "Base1::h" << endl; }
int data1;
int data2;
private:
};
class Base2
{
public:
virtual void f() { cout << "Base2::f" << endl; }
virtual void g() { cout << "Base2::g" << endl; }
virtual void h() { cout << "Base2::h" << endl; }
int data3;
int data4;
private:
};
class Base3
{
public:
virtual void f() { cout << "Base3::f" << endl; }
virtual void g() { cout << "Base3::g" << endl; }
virtual void h() { cout << "Base3::h" << endl; }
int data5;
int data6;
private:
};
class Derive : public Base1 , public Base2 , public Base3
{
public:
void f() { cout << "Derive::f" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
virtual void h1() { cout << "Derive::h1" << endl; }
int data7;
int data8;
private:
};
typedef void(*Fun)(void);
int main()
{
Derive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;
b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()
b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()
return 0;
}运行结果如下：
至此，我们应该对C++中的虚函数以及C++类对象的内存结构，有了一个比较深刻的认识。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
