探索VS中C++多态实现原理

引言

最近把《深度探索c++对象模型》读了几遍，收获甚大。明白了很多以前知其然却不知其所以然的姿势。比如构造函数与拷贝构造函数什么时候被编译器合成，虚函数、实例函数、类函数的区别等等。在此，我根据书本上的描述，结合VS2012的C++编译器，来验证其内容的正确性。让我们一起以指针寻址、虚函数表等理论作为依据，以汇编代码来实证，探索C++多态的实现。

#include <iostream>

using namespace std;

class Base

{

public:

    virtual void Test()

    {

        cout << "Base::Test()" << endl;

    }

};

class Derived : public Base

{

public:

    virtual void Test()

    {

        cout << "Derived::Test()" << endl;

    }

};

int main()

{

    Derived d;

    Base *b = &d;

    // 在这里，大家都知道输出的是Derived::Test(),因为多态。

    // 但是它到底是如何实现的呢？

    b->Test();

}

谈到多态，就不得不聊聊虚函数表了，有关虚函数表的内存布局请点击这。但是虚函数表是怎么创建的？又是怎么使用的？虚函数表里都是函数的指针，怎么找到欲对应的函数指针？下面，我们从最基本的指针寻址开始，一步步解答这些问题。

指针类型的作用

当我们写定义一个指针时，其对应的类型大小，便是其指向的内存范围的大小，例如int *pi， pi指向的是一块sizoef(int)大小的内存，char *pc;则指向的是一块sizeof(char)大小的内存。为什么要知道其指向的内存大小？举个例子，如下图：

如果ptr是一个char*指针，那么此时*ptr的值是0x78，因为它指向的类型是一个char，所以其内存范围是sizeof(char)，即1。如果是ptr是short*类型的则*ptr的值为0x5678。我们来写代码验证一下：

#include <iostream>

#include <limits>

using namespace std;

class Base

{

public:

    virtual void Test()

    {

        cout << "Base::Test()" << endl;

    }

};

class Derived : public Base

{

public:

    virtual void Test()

    {

        cout << "Derived::Test()" << endl;

    }

};

int main()

{

//     Derived d;

//     Base *b = &d;

// 

//     // 在这里，大家都知道输出的是Derived::Test(),因为多态。

//     // 但是它到底是如何实现的呢？

//     b->Test();

    int i = 0x12345678;

    char *pc = (char *)&i;

    cout << hex << "pc = 0x" << (int)*pc << endl;

    short *ps = (short *)&i;

    cout << hex << "ps = 0x" << (int)*ps << endl;   

}

运行时，可以观察两个指针指向的地址，及其指向地址处的内存数据：

可以看到，两个指针都指向i的地址0x0038fed8处，该地址处依次存放着78 56 34 12。我们来看看输出：

果然如此。现在，我们来看看生成的汇编代码是怎么样的：

汇编代码忠实的反应出了指针类型的信息。现在，我们得到一个结论：要通过一个内存地址去取值，必须知道1、内存地址是多少；2、欲取得的值占用多少字节内存。现在我们来测试一下自定义的class类型，看看其指针是如何工作的，代码如下：

#include <iostream>

#include <limits>

using namespace std;

class Base

{

public:

    virtual void Test()

    {

        cout << "Base::Test()" << endl;

    }

};

class Derived : public Base

{

public:

    virtual void Test()

    {

        cout << "Derived::Test()" << endl;

    }

};

class Test

{

public:

    int a;

    int b;

    int c;

    int d;

};

int main()

{

//     Derived d;

//     Base *b = &d;

// 

//     // 在这里，大家都知道输出的是Derived::Test(),因为多态。

//     // 但是它到底是如何实现的呢？

//     b->Test();

//     int i = 0x12345678;

// 

//     char *pc = (char *)&i;

//     cout << hex << "pc = 0x" << (int)*pc << endl;

// 

//     short *ps = (short *)&i;

//     cout << hex << "ps = 0x" << (int)*ps << endl;   

    // 首先，初始化一个Test指针， 然后将其赋值给一个local Test object t。

    Test *pt = new Test;

    Test t = *pt;

}

Test类中，仅包含了四个int，此时sizeof(Test) == sizoef(int) * 4。注意，在此处，我们没有为其定义构造函数以及copy构造函数。而且因为类中没有virtual函数也没有有构造函数的数据成员，编译器也不会为这个类合成构造函数与copy构造函数。在上述最后一行代码中，通过*pt取值，应该会有 4个类似mov dword ptr的操作。我们来看看生成的汇编代码：

我们可以看到，其在赋值时，确实产生了4个 mov dword ptr的操作，说明其寻址的大小是sizeof(Test)（即4 * sizeof(int)）。而且在其初始化的时候，除了new操作有一个call，没有其他任何call，说明确实没有所谓的编译器合成的缺省构造函数被调用。这种仅包含内置数据类型的类比较简单，下面让我们一起探索一下比较复杂的。

有虚函数成员的类——虚函数表的构造

我们为Test类加上一个虚函数：

然后查看生成的汇编代码，比较其与没有虚函数时，有什么不同：

通过生成的汇编代码，我们可以清楚的看到，类的大小增大了四个字节，并且编译器为我们合成了一个构造函数。赋值的时候，不再是挨个mov dword ptr了， 而是调用copy构造函数。为什么会这样？很简单，因为编译器要为我们构造虚函数表，虚函数表的初始化，就是在编译器为我们生成的构造函数里进行的。进而可以理解，为什么会合成copy构造函数了，如果不合成，那么赋值时，虚函数表岂不是无法赋值！我们跟进构造函数，看看编译器为我们生成的构造函数里有哪些代码：

同理，跟进copy构造函数：

啊哈，该有的一个都没少。

虚函数表的使用——多态的实现

回到本篇开头的代码，我们一起看一下d的地址，以及存放在指针b中的地址：

我们先不看生成的汇编代码，先来猜想一下调用的过程：将d的地址赋给b后，他们的寻址大小改变了，&d的寻址大小是sizeof(Derived)，而b的寻址大小是sizeof(Base)，（在此处，由于两者都是仅含一个虚函数，所以两者一样大。）。但是两个对象的内存布局有一部分是一样的，两个类的虚函数表的地址都存放在对象的首位，即对象的地址。所以理论上来说，d是可以寻址到该函数的。下面，我们看看汇编代码是如何写的：

虚函数地址，是个2级地址。对象地址首四位存放的是虚函数表的地址，虚函数表的第一个slot（即首个地址）存放的是第一个虚函数的地址，依次类推。详细参考代码请点击这。由于这里是单继承，所以类结构比较简单，类指针转换时，可以直接看做：基类对象的首地址等于派生类对象的首地址。下面我们来看一下稍微复杂一点的多继承情况，并且将派生类的对象地址赋值给第二个基类指针。代码如下：

#include <iostream>

#include <limits>

using namespace std;

class Base

{

public:

    virtual void Test()

    {

        cout << "Base::Test()" << endl;

    }

};

class AnotherBase

{

public:

    virtual void AnotherTest()

    {

        cout << "AnotherBase::AnotherTest()" << endl;

    }

};

class Derived : public Base, public AnotherBase

{

public:

    virtual void Test()

    {

        cout << "Derived::Test()" << endl;

    }

    virtual void AnotherTest()

    {

        cout << "Derived::AnotherTest()" << endl;

    }

};

class Test

{

public:

    virtual void Print()

    {

        cout << "Test::Print" << endl;

    }

    int a;

    int b;

    int c;

    int d;

};

int main()

{

//     Derived d;

//     Base *b = &d;

// 

//     // 在这里，大家都知道输出的是Derived::Test(),因为多态。

//     // 但是它到底是如何实现的呢？

//     b->Test();

    Derived d;

    AnotherBase *pAB = &d;

//    int i = 0x12345678;

// 

//     char *pc = (char *)&i;

//     cout << hex << "pc = 0x" << (int)*pc << endl;

// 

//     short *ps = (short *)&i;

//     cout << hex << "ps = 0x" << (int)*ps << endl;   

    // 首先，初始化一个Test指针， 然后将其赋值给一个local Test object t。

//     Test *pt = new Test;

// 

//     Test t = *pt;

}

我们再来看看他们的地址：

这是神马情况？我们明明把d的地址赋给了pAB呀！！！这不科学。我们一起去汇编代码里找原因去：

基本得到的信息与上面地址值对应：pAB中存的地址比d对象的地址大4个字节，然后以pAB中存的地址作为指针，辗转两次调用虚函数。很显然，这个+4的操作是编译器帮我们生成的，那么为什么要+4呢？我们来看一下派生类的对象内存布局：

这个对象有两个虚函数表，画出来应该是这样：

作为对比，我们来看下Derived对象自己来调用虚函数时，是个什么情况：

以Derived对象的指针来调用虚函数时，是个什么情况：

在这里，我们看到派生类对象无论是通过指针还是直接调用虚函数，其this参数，都会+4，即派生类包含该基类的内存布局的偏移。看来，调用虚函数时，总是以基类的“身份”去调用的。

现在，我们知道是如何调用到虚函数的了。但是还有个疑问：如果在派生类Derived中定义一个数据成员，并在虚函数中使用。那么基类的指针，如何寻址到该地址呢？毕竟寻址范围是根据指针类型来确定的。让我们一起去探索这最后的疑问：

分析图如下：

搞到最后，才发现调用虚函数的，其实一直是基类的指针。只是在对应的派生类虚函数实现里，修正了基类指针相对于派生类对象首地址的偏移。

总结

要实现多态，需要这么多的工具配合：虚表机制；派生类对象赋值给基类对象时，编译器添加指针相对偏移代码；虚函数内，编译器生成相应的偏移指针调用派生类数据成员的代码。多态，用起来轻快方便，实现起来难呀！

发现了个VS的bug，如果在调用虚函数时，this指针的值会在保存寄存器值后，无缘无故改变。变成对象的地址。其实是个假的值，查看内存即可知道。有可能是为了在调试时对用户透明故意为之，以免普通用户奇怪：居然this指针的值与对象值不同，囧…Orz。