C++多态篇3——虚函数表详解之多继承、虚函数表的打印
在上上一篇C++多态篇1一静态联编，动态联编、虚函数与虚函数表vtable中，我最后简单了剖析了一下虚函数表以及vptr。
而在上一篇文章C++多态篇2——虚函数表详解之从内存布局看函数重载，函数覆盖，函数隐藏中我详细介绍了虚函数的函数重载，函数覆盖以及函数隐藏的问题，其实在那一篇文章中，对单继承的虚函数已经做了十分详细的解答了，如果对前面有兴趣的人可以先看一下那篇文章。
在这一篇中，我会具体的分析一下在不同继承中（单继承，多继承）关于虚函数表在内存中的布局以及如何打印虚函数表。
一、虚函数表的打印
在前面的文章中我仅仅通过内存以及汇编代码中分析了虚函数表，现在我就再介绍一种查看虚函数表的方法， 即打印虚函数表
我们都知道如果类中一旦有了虚函数，那么编译器会自动给类中加四个字节的数据，这四个字节为指向虚函数表的指针，存放的是虚函数表在内存中的地址。
如果用代码表示即：
void* vftable_of_A[] = {A::v_fn, ...};
//A类的虚函数表
class A
{
const void* vftable = vftable_of_A;
//指向虚函数表的指针vftable
virtual void v_fn()
{}
}；
void* vftable_of_B[] = {B::v_fn,...};
//B类的虚函数表
class B
{
const void *vftable = vftable_of_B;
//指向B类虚函数表的指针vftable
vritual void v_fn()
{}
}; 其实上面的代码我们还需要注意两个问题：
1.为什么虚函数表指针的类型为void*？
答：上面vftable的类型之所以用void*表示，*实际上一个类中所有虚函数的地址都被放到这个表中，不同虚函数对应的函数指针类型不尽相同，所以这个表的类型无法确定，但是在机器级里都是入口地址，即一个32位的数字（32位系统），等到调用时，因为编译器预先知道了函数的参数类型，返回值等，可以自动做好处理。
2.为什么虚函数表前要加const？
答：因为虚函数表是一个常量表，在编译时，编译器会自动生成，并且不会改变，所以如果有多个B类的实例，每个实例中都会有一个vftable指针，但是它们指向的是同一个虚函数表。
那么我们如何才能打印虚函数表呢？
首先我们用上一篇用过的例子。
class Base
{
public:
Base(int data = 1)
:b(data)
{
cout << "Base()" << endl;
}
~Base()
{
cout << "~Base()" << endl;
}
virtual void Test1()
{
cout << "Base::Test1()" << endl;
}
virtual void Test2()
{
cout << "Base::Test2()" << endl;
}
virtual void Test3()
{
cout << "Base::Test3()" << endl;
}
int b;
};
class Derive :public Base
{
public:
Derive(int data = 2)
:d(data)
{
cout << "Derive()" << endl;
}
~Derive()
{
cout << "~Derive()" << endl;
}
void Test1()
{
cout << "Derive::Test1()" << endl;
}
void Test2()
{
cout << "Derive::Test2()" << endl;
}
int d;
};基类和派生类的定义如上：
那么我们再定义两个函数，分别用来打印基类虚函数表以及派生类虚函数表。
typedef void(*VTable)();//定义函数指针
void PrintBase(Base &b)
{
VTable vtb = (VTable)(*((int *)*(int *)&b));
//vtb就是函数的地址
int i = 0;
cout << "Vtable is " << endl;
while (vtb != NULL)
{
cout << "NUM " << ++i << "Function " << endl;
cout << "------->";
vtb();
vtb = (VTable)*(((int*)(*(int *)&b)) + i);
//向后偏移四个字节
}
cout << "End" << endl;
}
void PrintDerive(Derive &b)
{
VTable vtb = (VTable)(*((int *)*(int *)&b));
//vtb就是函数的地址
int i = 0;
cout << "Vtable is " << endl;
while (vtb != NULL)
{
cout << "NUM " << ++i << "Function " << endl;
cout << "------->";
vtb();
vtb = (VTable)*(((int*)(*(int *)&b)) + i);
//向后偏移四个字节
}
cout << "End" << endl;
}在main函数中进行调用：
int main()
{
Base b;
Derive d;
PrintBase(b);
PrintDerive(d);
return 0;
} 打断点一步一步运行得到：
现在我对上面的代码进行一下解释：
首先我们要定义一个函数指针用来调用函数。
即：
typedef void(*VTable)();//定义函数指针接着我们将基类对象b的首四个字节给vtb变量。
VTable vtb = (VTable)(*((int *)*(int *)&b));
这时vtb即为虚函数表中第一个函数的地址了。
后面我们进行调用，但因为每个函数的地址均为四个字节的，所以我们每次调用一个函数，给vtb偏移四个字节即可以取到下一个函数的地址了。
所以：
vtb();//先调用函数
vtb = (VTable)*(((int*)(*(int *)&b)) + i);
//再偏移四个字节 这样知道vtb指向的是NULL，即到了虚函数的结束部分，就跳出循环。
这样就可以打印出虚函数表的内容了。
派生类的虚函数表打印同理，因为虚函数表在派生类中存储的机制相同。只不过形参类型变了而已。
二、单继承
因为上一篇文章中我已经讲了很多关于单继承时虚函数表的问题，在这里我不再赘述很多基础的问题，如果对这里不熟悉的人可以去看我上一篇文章，在这里我举一个简单的例子说明一下在单继承时，虚函数表的内存布局。
class Base
{
public:
Base(int data = 1)
:b(data)
{
cout << "Base()" << endl;
}
~Base()
{
cout << "~Base()" << endl;
}
virtual void Test1()
{
cout << "Base::Test1()" << endl;
}
virtual void Test2()
{
cout << "Base::Test2()" << endl;
}
virtual void Test3()
{
cout << "Base::Test3()" << endl;
}
int b;
};
class Derive :public Base
{
public:
Derive(int data = 2)
:d(data)
{
cout << "Derive()" << endl;
}
~Derive()
{
cout << "~Derive()" << endl;
}
void Test1()
{
cout << "Derive::Test1()" << endl;
}
void Test2()
{
cout << "Derive::Test2()" << endl;
}
int d;
};
int main()
{
Base b;
b.Test1();
b.Test2();
b.Test3();
Derive d;
d.Test1();
d.Test2();
d.Test3();
return 0;
} 从代码可以看出在基类定义了三个虚函数，根据我们以前所说的知识，我们知道基类会生成一个虚函数表，那么派生类中我们定义了两个同名同参数的函数，为了让函数覆盖的现象更加明显，我特意没有将Test3（）定义，那么我们现在看一下运行结果：
由结果可知，基类对象调用的是基类的函数。派生类对象调用的是什么呢？
我们进入内存中查看一下：
三、多继承
1.不带函数覆盖
先看一下下面的例子：
class Base1
{
public:
Base1(int data = 1)
:b1(data)
{
cout << "Base1()" << endl;
}
~Base1()
{
cout << "~Base1()" << endl;
}
virtual void Test1()
{
cout << "Base1::Test1()" << endl;
}
virtual void Test2()
{
cout << "Base1::Test2()" << endl;
}
virtual void Test3()
{
cout << "Base1::Test3()" << endl;
}
int b1;
};
class Base2
{
public:
Base2(int data = 2)
:b2(data)
{
cout << "Base2()" << endl;
}
~Base2()
{
cout << "~Base2()" << endl;
}
virtual void Test4()
{
cout << "Base2::Test4()" << endl;
}
virtual void Test5()
{
cout << "Base2::Test5()" << endl;
}
virtual void Test6()
{
cout << "Base2::Test6()" << endl;
}
int b2;
};
class Derive :public Base1,public Base2
{
public:
Derive(int data = 3)
:d(data)
{
cout << "Derive()" << endl;
}
~Derive()
{
cout << "~Derive()" << endl;
}
int d;
}; 我们看一下这个多继承中派生类d的内存布局：
现在我们知道了内存布局，我们就可以打印出派生类的虚函数表了。
因为在多继承中有多个虚函数表，所以我们现在要改一下打印函数，下面的代码是我已经改过的。
void PrintDerive(Derive &b)
{
VTable vtb = (VTable)(*((int *)*(int *)&b));
//打印Derive中Base1的虚函数表
//vtb就是函数的地址
int i = 0;
cout << "Vtable is " << endl;
while (vtb != NULL)
{
cout << "NUM " << ++i << "Function " << endl;
cout << "------->";
vtb();
vtb = (VTable)*(((int*)(*(int *)&b)) + i);
//向后偏移四个字节
}
cout << "End" << endl;
/*************************/
//打印Derive中Base2的虚函数表
vtb = (VTable)(*((int *)*((int *)&b+2)));
//vtb就是函数的地址
i = 0;
cout << "Vtable is " << endl;
while (vtb != NULL)
{
cout << "NUM " << ++i << "Function " << endl;
cout << "------->";
vtb();
vtb = (VTable)*(((int*)(*((int *)&b+2))) + i);
//向后偏移四个字节
}
cout << "End" << endl;
} 因为我们已经知道了派生类的内存布局，所以我们打印Base2的虚函数表的时候，改一下vtb的值即可，我现在以内存的角度剖析一下如何改变vtb的值。
我们将打印函数加入main函数中，打印出来的结果为：
2.带函数覆盖
下面我们再来看看带函数覆盖的多继承的情况：
class Base1
{
public:
Base1(int data = 1)
:b1(data)
{
cout << "Base1()" << endl;
}
~Base1()
{
cout << "~Base1()" << endl;
}
virtual void Test1()
{
cout << "Base1::Test1()" << endl;
}
virtual void Test2()
{
cout << "Base1::Test2()" << endl;
}
virtual void Test3()
{
cout << "Base1::Test3()" << endl;
}
int b1;
};
class Base2
{
public:
Base2(int data = 2)
:b2(data)
{
cout << "Base2()" << endl;
}
~Base2()
{
cout << "~Base2()" << endl;
}
virtual void Test1()
{
cout << "Base2::Test1()" << endl;
}
virtual void Test2()
{
cout << "Base2::Test2()" << endl;
}
virtual void Test3()
{
cout << "Base2::Test3()" << endl;
}
virtual void Test4()
{
cout << "Base2::Test4()" << endl;
}
virtual void Test5()
{
cout << "Base2::Test5()" << endl;
}
virtual void Test6()
{
cout << "Base2::Test6()" << endl;
}
int b2;
};
class Derive :public Base1,public Base2
{
public:
Derive(int data = 3)
:d(data)
{
cout << "Derive()" << endl;
}
~Derive()
{
cout << "~Derive()" << endl;
}
void Test1()
{
cout << "Derive::Test1()" << endl;
}
void Test4()
{
cout << "Derive::Test4()" << endl;
}
int d;
};
typedef void(*VTable)();//定义函数指针
void PrintDerive(Derive &b)
{
VTable vtb = (VTable)(*((int *)*(int *)&b));
//打印Derive中Base1的虚函数表
//vtb就是函数的地址
int i = 0;
cout << "Vtable is " << endl;
while (vtb != NULL)
{
cout << "NUM " << ++i << "Function " << endl;
cout << "------->";
vtb();
vtb = (VTable)*(((int*)(*(int *)&b)) + i);
//向后偏移四个字节
}
cout << "End" << endl;
/*************************/
//打印Derive中Base2的虚函数表
vtb = (VTable)(*((int *)*((int *)&b+2)));
//vtb就是函数的地址
i = 0;
cout << "Vtable is " << endl;
while (vtb != NULL)
{
cout << "NUM " << ++i << "Function " << endl;
cout << "------->";
vtb();
vtb = (VTable)*(((int*)(*((int *)&b+2))) + i);
//向后偏移四个字节
}
cout << "End" << endl;
}
int main()
{
Derive d;
PrintDerive(d);
return 0;
}
运行结果为：
由结果可以得到，Test1（）不仅覆盖了Base1中的Test1()函数，也覆盖了Base2类中的Test1()函数。
现在关于单继承和多继承中虚函数表的问题，应该都解释的差不多啦，如果还有问题，欢迎留言提出~