孔乙己之四----虚函数(中)

本文作者:sodme本文出处:http://blog.csdn.net/sodme声明: 本文可以不经作者同意, 任意复制, 转载, 但任何对本文的引用都请保留文章开始前三行的作者, 出处以及声明信息. 谢谢.听着窗外的大粒雨点声睡觉, 是一种特别的享受. 这两天恰逢台风登陆, 广州也连日的雨下个不停. 在这样的雨夜里, 收拾一下心情, 决定继续用ASM研究C++的对象模型. 写文章, 还是很需要好心情的. 心情不好的时候, 即使憋出了内容, 亦了无生趣. 而于我等作技术的人, 除了玩玩技术之外, 在文字方面给自己, 同时也多给读者一些阅读或写作的乐趣, 实在是一种明智之举. 所以, 我的习惯是: 只有心情好的时候, 才落笔.   没错, 早在写这个孔乙己系列之前, 我就知道在C++对象模型的研究和介绍方面, 早就有了经典之作"Inside the C++ Object Model". 但是, 那毕竟是人家写的东西, 不是我亲自研究弄明白的东西. 之所以写作这个系列, 是想通过ASM分析这种方法, 对C++对象模型有个更全面, 更深刻, 也更感性的认识. 可以看看各种编译器在对C++标准支持方面是如何作的. 而在分析过程中, 对ASM分析方法的进一步熟悉, 则是意料之中的小小收获了. 至于这种黑箱分析所带来的乐趣, 则更是只能意会不能言传了.  虽然此文的标题是"虚函数", 但本文实际上是围绕着这样一个中心点展开诸多内容, 包括: 单继承, 多继承, 以及在两个类发生继承关系时, 他们的数据和函数又是如何处理的?  文章将按以下主线展开: 单继承下的虚函数机制分析, 多继承下的虚函数机制分析.  c++要实现虚函数, 归纳起来, 其实只用干两件事: 1. 根据派生和继承关系, 生成虚函数表; 2. 将代码中对虚函数的调用, 转化成对虚函数表中各虚函数指针的间接调用.  虽然在上文中的那个小例子中, 我们通过反汇编出来的asm弄明白了以下事实: 1. 每个"类"所拥有的虚函数表的个数: 每个类都会对应"唯一的一份"虚函数表; 2. "对象"中虚函数表指针的保存位置: 在调用对象的构造函数时, 会把虚函数表指针放到this处(即: 对象首地址处), 所以属于同一个类的每个对象的this地址所指向的单元处存放的是同一个值; 3. 虚函数的调用转化: 编译器编译c++代码时, 根据类的相关信息, 判断此函数是不是虚函数, 如果是, 则从虚函数表中取出真正的虚函数地址, 生成真正的调用语句;  那么, 现在看来, 问题的核心就变成了: 这个统领全局的虚函数表到底是如何产生? 在生成虚函数表的过程中, 遵守了哪些规则呢? 带着这些疑问, 我们将开始今天的探索.   本文所需代码可从以下地址获得( 此地址含有单继承c++和asm代码 ):http://docs.google.com/Doc?id=dcb4rbgm_50ftk9j9f3 为了研究的方便, 此次对代码结构进行了较大规模的调整, 主要是: 1. 去除了对输入输出流的引用, 只保存逻辑代码, 不再include任何多余代码; 2. 声明了两个基类, 它们在单继承和多继承方式下会被拿来作不同的整合: 在单继承下, Base2Class派生于Base1Class, 而MyClass类派生于Base2Class类; 而在多继承下, 两个基类相互之间不再有派生关系, 它们会被MyClass一个类多继承.  先看单继承的情况. 三个类的派生关系如下: Base1Class -> Base2Class -> MyClass, 其派生规则为: 多层单继承.  其中,   Base1Class的虚函数表为:

    .long    _ZN10Base1Class14virtual_test_1Ev            ;Base1Class::virtual_test_1()    .long    _ZN10Base1Class14virtual_test_3Ev            ;Base1Class::virtual_test_3() 

 Base2Class的虚函数表为:

    .long    _ZN10Base1Class14virtual_test_1Ev            ;Base1Class::virtual_test_1()    .long    _ZN10Base2Class14virtual_test_3Ev            ;Base2Class::virtual_test_3()    .long    _ZN10Base2Class14virtual_test_2Ev            ;Base2Class::virtual_test_2() 

 MyClass的虚函数表为:

    .long    _ZN7MyClass14virtual_test_1Ev                ;MyClass::virtual_test_1()    .long    _ZN10Base2Class14virtual_test_3Ev            ;Base2Class::virtual_test_3()    .long    _ZN10Base2Class14virtual_test_2Ev            ;Base2Class::virtual_test_2()    .long    _ZN7MyClass15virtual_test_myEv                ;MyClass::virtual_test_my() 

 由这三个虚函数表, 我们发现了以下的规律:  1. 派生类会继承基类的所有非同名虚函数, 存放顺序同基类; 如: 在Base2Class中, virtual_test_1() 是 Base1Class的虚函数, 且在Base2Class中没有定义同名函数, 它的顺序是1, 因为在基类Base1Class中, 它的顺序就是1;  2. 当派生类与基类有同名虚函数时, 派生类的虚函数表中存放派生类的虚函数, 存放顺序与基类同名虚函数的存放位置相同; 如: 在Base2Class中, virtual_test_3() 在 Base1Class和Base2Class中都有, 那么在Base2Class的虚函数表中, 就只会存放Base2Class自己的虚函数, 但存放的顺序, 与它的基类Base2Class的存放顺序相同! 而"存放顺序必须相同", 这一点, 是C++实现动态重载的重要方法! 这一点, 后面分析构造函数运行流程时会说到.  3. 存放完所有与基类同名的虚函数 以及 基类有但派生类没有的所有虚函数后, 开始存放派生类的其它虚函数. 如: 在Base2Class的virtual_test_2() 和 MyClass的virtual_test_my(), 这两个函数, 都是派生类中存在而基类中不存在的, 它们存放的顺序都在上述两类虚函数的后面.  以上, 是关于单继承情况下虚函数表的静态结构分析. 那么, 我们来看看实际运行时, 构造函数又是如何利用这些数据将对象进行初始化的.  MyClass构造函数的主要语句:  

    movl    8(%ebp), %eax               ;申请的空间首地址, 即this指针    movl    %eax, (%esp)    call    _ZN10Base2ClassC2Ev         ;调用Base2Class的构造函数    movl    $_ZTV7MyClass+8, %edx       ;将MyClass的虚函数表地址放在edx中, 以便放在this处    movl    8(%ebp), %eax    movl    %edx, (%eax)                ;将虚表地址放在this处    movl    8(%ebp), %eax    movl    $1, 12(%eax)                ;[this+12] = 1 <==> data1 = 1    movl    8(%ebp), %eax    movl    $2, 16(%eax)                ;[this+16] = 2 <==> data2 = 2 

 可以看到, 在MyClass的构造函数中, 首先是调用了Base2Class的构造函数: __ZN10Base2ClassC2Ev.  Base2Class的构造函数:

    movl    8(%ebp), %eax                ;this指针    movl    %eax, (%esp)    call    _ZN10Base1ClassC2Ev          ;调用Base1Class的构造函数    movl    $_ZTV10Base2Class+8, %edx    ;将Base2Class虚表地址放在this处    movl    8(%ebp), %eax    movl    %edx, (%eax)    movl    8(%ebp), %eax    movl    $44, 8(%eax)                 ;[this+8] = 44  <==>  base_2_data = 44  

 而在Base2Class中, 又调用了Base1Class的构造函数:

    movl    $_ZTV10Base1Class+8, %eax   ;将Base1Class虚表地址放在this处    movl    8(%ebp), %edx    movl    %eax, (%edx)    movl    8(%ebp), %eax    movl    $33, 4(%eax)                ;[this+4] = 33  <==>  base_1_data = 33 

 从这三个构造函数的执行过程来看, 在Base1Class的构造函数中, 将Base1Class的虚函数表地址传到了this地址处, 在Base2Class的构造函数中, 将Base2Class的虚函数表地址也传到了this地址处, 同样的, 在MyClass的构造函数中, 把MyClass的虚函数表地址还是放在this地址处. 换句话说, 针对于同一个this地址处的这个虚函数表地址的赋值, C++竟然重复作了三次! 而最后一次的赋值, 才是我们真正需要的结果! 没错, C++在这里, 确实是作了两次"无用功". 我在想, 有没有办法避免这样的重复赋值呢? 有一种方法: 在调用构造函数时, 传个参数进来, 表示是不是派生类调用它的, 由个参数来决定是不是将虚函数表地址拿到this, 但是, 仔细算一下: "传递参数+判断" 这样的逻辑, 似乎还没有不管三七二十一直接赋值来得更为简单一些, 所以, 这样看来, C++选择这样作, 也是有充分理由的.  前面反复提到过虚函数的存放顺序. 那么, 这个顺序, 与C++的动态重载到底有多大关系呢? 我们先看这条语句: pMyClass->virtual_test_2();  C++在分析这条语句时, 首先会判断pMyClass是哪种类型, 此例中是MyClass, 然后判断它调用的函数是不是虚函数, 如果是虚函数, 则将调用形式转化为针对于虚函数表的间接调用.  而前面提到, 派生类中存在且在基类中也存在的虚函数, 在派生类虚函数表中的位置与基类位置相同. 所以, 不管是MyClass还是Base2Class的对象, 它们调用virtual_test_2()的汇编代码都是相同的:  pBaseClass->virtual_test_2():  

    movl    -12(%ebp), %eax     ; -12(%ebp)表示局部变量pBaseClass    movl    (%eax), %eax        ; 取虚表    addl    $8, %eax            ; 取virtual_test_2()存放地址    movl    (%eax), %edx        ; 取virtual_test_2()地址    movl    -12(%ebp), %eax    movl    %eax, (%esp)        ; 将this指针放栈顶传递    call    *%edx 

 pMyClass->virtual_test_2():  

    movl    -16(%ebp), %eax        ; -16(%ebp)表示局部变量pMyClass    movl    (%eax), %eax    addl    $8, %eax    movl    (%eax), %edx    movl    -16(%ebp), %eax    movl    %eax, (%esp)    call    *%edx 

 经过比对, 除了取this指针的局部变量地址不同, 其余代码均相同, 取虚函数地址时, 都是在this指针的基础上加8. 之所以可以作到这样, 就是因为有这个约定: 针对于同名函数, 它们在虚函数表中的位置相同. 当然, 这个约定并不一定要所有的编译器都来遵守, 针对于同一个编译器而言, 有一套约定就行了, 关键是要有约定, 而具体如何约定倒各有各的作法.  除此之外, 我们还发现, 在Base2Class类的virtual_test_2()函数中, 对于类Base2Class 数据成员base_2_data的访问, 已经被修正为this+8. 这是因为, 经过一系列的派生后, pMyClass对象结构变成如下的方式:              |                             |             |-----------------------------| this ->     |    类MyClass虚函数表地址    |        0             |-----------------------------|             | Base1Class::base_1_data     |        +4             |-----------------------------|             | Base2Class::base_2_data     |        +8             |-----------------------------|             |     MyClass::data1          |        +12             |-----------------------------|             |     MyClass::data2          |        +16             |-----------------------------|             |                             | 其规则是: this地址处存放最上层类的虚函数表地址, 然后向下依次存放各基类的数据成员, 其顺序按类中的声明顺序排列. 需要指出的是, 这里存放的数据, 不仅包括public的数据, 也同时包括private的数据. 道理很简单: 在调用某层类的函数时, 该函数中仍有可能要引用到私有数据, 尽管此私有数据不能被外部函数访问. 所以, 从这个层面上来说, 私有数据仅仅是C++自己的"君子"约定, 我们完全使用比较流氓的方法来访问它. 比如我们在类Base1Class增加一private数据, 修改为如下形式:

class Base1Class...{public:    Base1Class()...{ base_1_data = 33; };    ~Base1Class()...{};    int base_1_data;    virtual void virtual_test_1()...{ base_1_data = 10; };    virtual void virtual_test_3()...{ base_1_data = 11; };private:    int pri_base_1_data;}; 

 pri_base_1_data会被放在base_1_data和base_2_data之间. 如果要访问pri_base_1_data, 在取得this指针后, 我们就可以通过this+8来访问, 具体的c++代码可以是这样: *( (char*)pMyClass + 8 ) = (int)3333;  那么, C++如何区别这两条语句呢?   pBase2Class->virtual_test_2():  

    movl    -12(%ebp), %eax    movl    (%eax), %eax    addl    $8, %eax    movl    (%eax), %edx    movl    -12(%ebp), %eax    movl    %eax, (%esp)    call    *%edx 

 ((MyClass*)pBase2Class)->virtual_test_2():  

    movl    -12(%ebp), %eax    movl    (%eax), %eax    addl    $8, %eax    movl    (%eax), %edx    movl    -12(%ebp), %eax    movl    %eax, (%esp)    call    *%edx 

 pMyClass->virtual_test_2():  

    movl    -16(%ebp), %eax    movl    (%eax), %eax    addl    $8, %eax    movl    (%eax), %edx    movl    -16(%ebp), %eax    movl    %eax, (%esp)    call    *%edx 

 ((Base2Class*)pMyClass)->virtual_test_2():      

    movl    -16(%ebp), %eax    movl    (%eax), %eax    addl    $8, %eax    movl    (%eax), %edx    movl    -16(%ebp), %eax    movl    %eax, (%esp)    call    *%edx 

 比较完这四条语句的代码之后, 我们发现: 不管作不作类型转换, 其编译出的汇编代码全是一样的!  其实, 前面的类型转换只是后面是否可以调用某函数的类型约定, 至于此函数的具体执行行为, 则完全看对象本身的虚函数表是哪份以及this指针指向的数据是什么而定了, this指针指向的虚函数表决定了函数的最终行为归属, 而此表地址在对象初始化时被放在了对象首地址处, 这样想来, 好像前后的知识可以贯通了: 对于一个pBase2Class而言, 我如何知道形如这样的调用: pBase2Class->virtual_test_2();  它调用的到底是类Base2Class的, 还是MyClass的? 一切答案皆在虚函数表中. 对象与"某个类的虚函数表"绑定, 而virtual_test_2()则与"虚函数表地址+8"绑定, 要想知道调用的是哪个, 就看此时的this到底是哪个类的this.    也就是说, 在对virtual_test_2()此函数的调用上, 不管是Base2Class类的对象还是MyClass类的对象, 其调用的汇编代码完全一样, 唯一可以让它们有不同执行行为的, 就是"addl $8, &eax"后取出的虚函数地址. 比如: pBase2Class = new Base2Class; 则: ((MyClass*)pBase2Class)->virtual_test_my() 必定是非法的, 它会被转化成以下语句:  

    movl    -12(%ebp), %eax    movl    (%eax), %eax    addl    $12, %eax      ;根据类型为MyClass及函数为virtual_test_my()转化为"虚函数表地址+12"    movl    (%eax), %edx    movl    -12(%ebp), %eax    movl    %eax, (%esp)    call    *%edx 

 由此, 可以看出, 编译器会根据当前对象的类型, 决定如何编译virtual_test_my(), 这里的"类型", 指的是"调用时类型", 而不是简单的指"定义时类型", 因为调用时, 可能会进行强制类型转换. 这里, 尽管virtual_test_my()函数可以编译通过, 但通过"this->虚函数表+12"找出来的这个地址, 根据不是正常的函数地址, 此时this指向实际对象所拥有的虚函数表中最多只有2个虚函数(+8).