从汇编看c++中的虚拟继承及内存布局(二)

下面是c++源码:

class Top {//虚基类
public:
    int i;
    Top(int ii) {
        i = ii;
    }
    virtual int getTop() {
        cout << (long)this << endl;
        return 1;
    }
};

class Left : public virtual Top {
public:
    int j;
    Left(int jj, int ii) : Top(ii) {
        j = jj;
    }
    int getTop() {
        return 2;
    }
    virtual int getLeft() {
        return 1;
    }
};

class Right : public virtual Top {
public:
    int k;
    Right(int kk, int ii) : Top(ii) {
        k = kk;
    }
    int getTop() {
        return 3;
    }
    virtual int getRight() {
        return 1;
    }
};

class Bottom : public Left, public Right {
public:
    int l;
    Bottom(int ll, int jj, int kk, int ii) : Top(ii), Left(jj, ii), Right(kk, ii) {
        l = ll;
    }
    int getTop() {
        cout << (long)this << endl;
        return 4;
    }
    int getLeft() {
        return 2;
    }
    int getRight() {
        return 2;
    }
    virtual int getBottom() {
        return 1;
    }
};

int main() {
    Bottom b(1, 2, 3, 4);
    Bottom* bp = &b;
    //向上转换为Left
    Left* lp = bp;
    int lleft = lp->getLeft();
    int ltop = lp->getTop();
    //向上转换为Right
    Right* rp = bp;
    int rright = rp->getRight();
    int rtop = rp->getTop();
    //向上转换为Top
    Top* tp = bp;
    int ttop =tp->getTop();
    //bp指针自己调用
    int btop = bp->getTop();
    int bleft = bp->getLeft();
    int bright = bp->getRight();
    int bbottom = bp->getBottom();
};

其中，每一个类都有自己独有的一个虚函数，子类都会复写从父类继承而来的虚函数。

下面是main函数中的汇编码:

; 60   : int main() {

    push    ebp
    mov    ebp, esp
    sub    esp, 84                    ; 为程序中的变量预留存储空间，其中对象b占用40byte

; 61   :     Bottom b(1, 2, 3, 4);

    push    1;压入标志，1表示调用虚基类构造函数 0表示不调用虚基类构造函数
    push    4;压栈4，为对象b构造函数传递参数
    push    3;压栈3，为对象b构造函数传递参数
    push    2;压栈2，为对象b构造函数传递参数
    push    1;压栈1，为对象b构造函数传递参数
    lea    ecx, DWORD PTR _b$[ebp];将对象b的首地址给寄存器ecx，作为隐含参数传递给b的构造函数
    call    ??0Bottom@@QAE@HHHH@Z            ; 调用对象b的构造函数

; 62   :     Bottom* bp = &b;

    lea    eax, DWORD PTR _b$[ebp];获取对象b的首地址给寄存器eax
    mov    DWORD PTR _bp$[ebp], eax;将对象b的首地址给指针bp

; 63   :     //向上转换为Left
; 64   :     Left* lp = bp;

    mov    ecx, DWORD PTR _bp$[ebp];将对象b的首地址给寄存器ecx
    mov    DWORD PTR _lp$[ebp], ecx;将对象b的首地址给指针lp(因为父类Left对象首地址和对象b首地址一样)

; 65   :     int lleft = lp->getLeft();

    mov    edx, DWORD PTR _lp$[ebp];将父类Left对象首地址给edx寄存器
    mov    eax, DWORD PTR [edx];获取寄存器edx里面的内容(即vftable,虚表首地址)给寄存器eax
    mov    ecx, DWORD PTR _lp$[ebp];将父类Left对象首地址给寄存器ecx
    mov    edx, DWORD PTR [eax];将虚表首地址处内存内容(即虚函数getLeft的首地址)给寄存器edx
    call    edx;调用getLeft函数
    mov    DWORD PTR _lleft$[ebp], eax;寄存器eax里面含有getLeft函数返回的结果，写入变量lleft里面

; 66   :     int ltop = lp->getTop();

    mov    eax, DWORD PTR _lp$[ebp];获取父类对象Left的首地址给寄存器eax
    mov    ecx, DWORD PTR [eax+4];获取偏移父类对象Left首地址4byte处内存内容(即vbtable的首地址)给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top对象的虚表指针偏移父类Left对象vbtable指针的偏移量)，给寄存器edx
    mov    eax, DWORD PTR _lp$[ebp];获父类对象Left的首地址给寄存器eax
    mov    ecx, DWORD PTR [eax+4];获取偏移父类对象Left首地址4byte处内存内容(即vbtable的首地址)给寄存器ecx
    mov    eax, DWORD PTR [ecx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top对象的虚表指针偏移父类Left对象vbtable指针的偏移量)，给寄存器eax
    mov    ecx, DWORD PTR _lp$[ebp];获取父类对象Left的首地址给寄存器ecx
    lea    ecx, DWORD PTR [ecx+eax+4];ecx存放父类Left首地址，eax存放虚基类Top到父类Left对象的vbtable指针处的偏移量，两者相加，再加上
                                  ;父类Left对象自身的vptr指针大小4byte，得到虚基类Top对象首地址，给寄存器ecx
    mov    eax, DWORD PTR _lp$[ebp];获取父类Left对象的首地址给寄存器eax
    mov    edx, DWORD PTR [eax+edx+4];寄存器eax存放父类Left对象首地址，寄存器edx存放虚基类Top到父类对象vbtable指针处偏移量，两者相加，
                                  ;再加上父类Left对象自身的vptr指针大小4byte，得到虚基类Top对象的首地址，然后在取虚基类Top对象首地址
                                  ;处内容(即vftable首地址)给寄存器edx
    mov    eax, DWORD PTR [edx];将虚表首地址处内容(即虚函数getTop的首地址)给寄存器eax
    call    eax;调用虚函数getTop
    mov    DWORD PTR _ltop$[ebp], eax;寄存器eax里面含有调用getTop函数的返回值，写入变量ltop

; 67   :     //向上转换为Right
; 68   :     Right* rp = bp;

    cmp    DWORD PTR _bp$[ebp], 0;比较对象b首地址是否为0，即判断bp指针是否为空
    je    SHORT $LN3@main;如果bp指针为空，就会跳转到标号$LN3@main处执行，否则顺序执行 这里顺序执行
    mov    ecx, DWORD PTR _bp$[ebp];获取对象b的首地址给寄存器ecx
    add    ecx, 12                    ; 将对象b的首地址加上12，的到父类Right对象首地址，存到寄存器ecx
    mov    DWORD PTR tv133[ebp], ecx;将父类Right的首地址给临时变量tv133
    jmp    SHORT $LN4@main;跳转掉标号$LN4@main处执行
$LN3@main:
    mov    DWORD PTR tv133[ebp], 0;如果指针bp为空指针，临时变量tv133将会赋值0
$LN4@main:
    mov    edx, DWORD PTR tv133[ebp];将临时变量tv133的值给寄存器edx
    mov    DWORD PTR _rp$[ebp], edx;将寄存器edx的内容给rp指针。要是bp指针判断不为空，rp指针保存的就是父类Right对象首地址
                                ;这里完成了bp指针到rp指针的转化
                                ;在转化的过程中之所以要判断bp指针是否为0，是因为rp指针所指向的内存地址，是由bp指向的内存地址
                                ;加上一定的偏移量得来(这里是12byte)，如果不进行判断，一旦bp为空指针，rp就会指向错误的内存。编译器必须防止
                                ;这类错误发生

; 69   :     int rright = rp->getRight();

    mov    eax, DWORD PTR _rp$[ebp];将父类Right对象首地址给寄存器eax
    mov    edx, DWORD PTR [eax];将父类Right对象首地址处内容(即vftable首地址)给寄存器edx
    mov    ecx, DWORD PTR _rp$[ebp];获取父类Right对象的首地址，给寄存器ecx
    mov    eax, DWORD PTR [edx];获取虚表首地址处的内容(即虚函数getRigt首地址)给寄存器eax
    call    eax;调用getRight函数
    mov    DWORD PTR _rright$[ebp], eax;eax里面含有调用getRight函数后的返回结果，这里将结果写给rright变量

; 70   :     int rtop = rp->getTop();

    mov    ecx, DWORD PTR _rp$[ebp];将父类Right对象的首地址给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移父类Right对象首地址4byte处内存内容(即vbtable首地址)给寄存器edx
    mov    eax, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top的虚表指针偏移vbtable指针的偏移量)，给寄存器eax
    mov    ecx, DWORD PTR _rp$[ebp];获取父类Right对象的首地址给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移父类Right对象首地址4byte处内存内容(即vbtable首地址)给寄存器edx
    mov    ecx, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top的虚表指针偏移vbtable指针的偏移量)，给寄存器ecx
    mov    edx, DWORD PTR _rp$[ebp];获取父类Right对象的首地址给寄存器edx
    lea    ecx, DWORD PTR [edx+ecx+4];edx寄存器里面保存的是父类Right对象首地址，ecx里面保存的是虚基类Top的虚表指针到父类Right对象vbtable的偏移量
                                  ;两者相加，再加上父类Right对象自身的vptr指针大小4byte，即的到虚基类Top对象首地址，将该地址保存到寄存器ecx
    mov    edx, DWORD PTR _rp$[ebp];获取父类Right对象首地址给寄存器edx
    mov    eax, DWORD PTR [edx+eax+4];edx寄存器里面保存的是父类Right对象首地址，eax里面保存的是虚基类Top的虚表指针到父类Right对象vbtable的偏移量
                                  ;两者相加，再加上父类Right对象自身的vptr指针大小4byte，即的到虚基类Top对象首地址，将该地址处内容(即vftable首地址)
                                  ;给寄存器eax
    mov    edx, DWORD PTR [eax];获取vftable首地址处内容，即虚函数getTop的首地址，给寄存器edx
    call    edx;调用虚函数getTop
    mov    DWORD PTR _rtop$[ebp], eax;eax里面含有调用函数返回的结果，保存到变量rtop

; 71   :     //向上转换为Top
; 72   :     Top* tp = bp;

    cmp    DWORD PTR _bp$[ebp], 0;比较bp指针是否为0，即判断bp指针是否为空
    jne    SHORT $LN5@main;如果为空，就顺序执行，否则，就跳转到标号$LN5@main处执行 这里跳转到标号执行
    mov    DWORD PTR tv170[ebp], 0;将0赋给临时变量tv170
    jmp    SHORT $LN6@main;跳转到标号$LN6@main执行
$LN5@main:
    mov    eax, DWORD PTR _bp$[ebp];将对象b首地址给寄存器eax
    mov    ecx, DWORD PTR [eax+4];获取偏移对象b首地址4byte处内存内容(即vbtable首地址)给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移vbtable首地址4byte处内存内容，即虚基类Top虚表指针到vbtable指针的偏移量，给寄存器edx
    mov    eax, DWORD PTR _bp$[ebp];将对象b的首地址给寄存器eax
    lea    ecx, DWORD PTR [eax+edx+4];eax里面保存对象b的首地址，edx里面保存虚基类Top虚表指针对象b的vbtable指针的偏移量，
                                  ;两者相加，在加上对象b自身的vtpr指针大小(4byte），获得虚基类Top的首地址，存到寄存器ecx
    mov    DWORD PTR tv170[ebp], ecx;将虚基类Top的首地址给临时变量tv170
$LN6@main:
    mov    edx, DWORD PTR tv170[ebp];将tv170里面的内容给寄存器edx
    mov    DWORD PTR _tp$[ebp], edx;将寄存器edx里面的内容给tp指针。如果bp指针不为空，那么tp指针保存的就是虚基类Top的首地址
                                ;到这里，由bp指针转换到top指针结束

; 73   :     int ttop =tp->getTop();

    mov    eax, DWORD PTR _tp$[ebp];获取虚基类首地址给寄存器eax
    mov    edx, DWORD PTR [eax];将虚基类Top首地址处内存内容给寄存器edx，即将vftable首地址给寄存器edx
    mov    ecx, DWORD PTR _tp$[ebp];将虚基类首地址给寄存器eax
    mov    eax, DWORD PTR [edx];将虚表首地址处内容(即虚函数Top的首地址)给寄存器eax
    call    eax;调用虚函数getTop
    mov    DWORD PTR _ttop$[ebp], eax;eax寄存器里面保存函数调用结果，写入变量ttop
    
    ;75
    ; 76   :     int btop = bp->getTop();

    mov    ecx, DWORD PTR _bp$[ebp];获取对象b的首地址给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移对象首地址4字节处的内存内容(即vbtable首地址)给寄存器edx
    mov    eax, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top虚表指针偏移对象b的vbtable指针的偏移量),写入寄存器eax
    mov    ecx, DWORD PTR _bp$[ebp];获取对象b的首地址ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移对象首地址4字节处的内存内容(即vbtable首地址)给寄存器edx
    mov    ecx, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top虚表指针偏移对象b的vbtable指针的偏移量),写入寄存器ecx
    mov    edx, DWORD PTR _bp$[ebp];获取对象b首地址给寄存器edx
    lea    ecx, DWORD PTR [edx+ecx+4];edx里面保存有对象b的首地址，ecx里面保存虚基类Top虚表指针到对象b的vbtable指针的偏移量
                                  ;二者相加，再加上对象b自身的vptr指针大小4byte，得到虚基类Top首地址，存放到寄存器ecx
    mov    edx, DWORD PTR _bp$[ebp];获取对象b的首地址，给寄存器edx
    mov    eax, DWORD PTR [edx+eax+4];edx里面保存有对象b的首地址，eax里面保存虚基类Top虚表指针到对象b的vbtable指针的偏移量
                                  ;二者相加，再加上对象b自身的vptr指针大小4byte，得到虚基类Top首地址，存放到寄存器eax
    mov    edx, DWORD PTR [eax];获取虚基类首地址处内容(即vftable首地址)给寄存器eax，即虚函数getTop首地址
    call    edx;调用虚函数getTop
    mov    DWORD PTR _btop$[ebp], eax;eax保存函数getTop调用的返回结果，存放到btop变量

; 77   :     int bleft = bp->getLeft();

    mov    eax, DWORD PTR _bp$[ebp];获取对象b的首地址保存到寄存器eax
    mov    edx, DWORD PTR [eax];获取对象b首地址处的内容(即vftable首地址)给寄存器edx
    mov    ecx, DWORD PTR _bp$[ebp];获取对象b的首地址给寄存器ecx
    mov    eax, DWORD PTR [edx];获取虚表首地址处内容给寄存器eax，即虚函数getLeft的首地址
    call    eax;调用虚函数getLeft
    mov    DWORD PTR _bleft$[ebp], eax;eax里面含有调用getLeft函数的返回结果，写入bleft变量

; 78   :     int bright = bp->getRight();

    mov    ecx, DWORD PTR _bp$[ebp];获取对象b首地址给寄存器ecx
    add    ecx, 12                    ; 将对象b的首地址加上12，即得到父类Right对象首地址，保存到寄存器ecx
    mov    edx, DWORD PTR _bp$[ebp];获取对象b的首地址，给寄存器edx
    mov    eax, DWORD PTR [edx+12];edx寄存器保存对象b首地址，加上12得到父类Right对象首地址，然后将父类Right对象首地址
                                ;处内容(即vftable首地址)给寄存器eax
    mov    edx, DWORD PTR [eax];获取虚表vftable首地址处内容(即虚函数getRight首地址),给寄存器edx
    call    edx;调用虚函数getRight
    mov    DWORD PTR _bright$[ebp], eax;eax里面保存调用函数getRight的结果，写入变量bright

; 79   :     int bbottom = bp->getBottom();

    mov    eax, DWORD PTR _bp$[ebp];获取对象b的首地址，给寄存器eax
    mov    edx, DWORD PTR [eax];获取对象首地址内容(即vftable首地址)给寄存器edx
    mov    ecx, DWORD PTR _bp$[ebp];获取对象b首地址给寄存器ecx
    mov    eax, DWORD PTR [edx+4];获取偏移虚表vftable首地址4字节处内存内容(即虚函数getBottom的首地址)，给寄存器eax
    call    eax;调用虚函数getBottom
    mov    DWORD PTR _bbottom$[ebp], eax;eax里面保存调用函数getBottom后的结果，写入变量bbottom

; 80   :     

; 81   :     
; 82   : };

    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0
_main    ENDP

下面是Bottom构造函数的汇编码:

??0Bottom@@QAE@HHHH@Z PROC                ; Bottom::Bottom, COMDAT
; _this$ = ecx

; 44   :     Bottom(int ll, int jj, int kk, int ii) : Top(ii), Left(jj, ii), Right(kk, ii) {

    push    ebp
    mov    ebp, esp
    push    ecx;压栈ecx的目的是为了保存对象b的首地址预留空间
    mov    DWORD PTR _this$[ebp], ecx;ecx寄存器里面保存着对象b的首地址，存到刚才预留的空间
    cmp    DWORD PTR _$initVBases$[ebp], 0;_$initVBases所代表的内存存放着调用Bottom构造函数之前压入的标志，这里将标志与0进行比较
    je    SHORT $LN1@Bottom;比较结果为0，即标志为0，就跳转到标号$LN1@Bottom处执行，避免重复调用虚基类构造函数 否则顺序执行 这里顺序执行
    mov    eax, DWORD PTR _this$[ebp];将对象b的首地址给寄存器eax
    mov    DWORD PTR [eax+4], OFFSET ??_8Bottom@@7BLeft@@@;将??_8Bottom@@7BLeft@@@所代表的内存地址(即vbtable首地址)写入偏移对象
                                                       ;首地址4byte处内存，即赋值vbtable指针
    mov    ecx, DWORD PTR _this$[ebp];将对象首地址给寄存器ecx
    mov    DWORD PTR [ecx+16], OFFSET ??_8Bottom@@7BRight@@@;将??_8Bottom@@7BRight@@@所代表的内存地址(即vbtable首地址)写入偏移对象
                                                         ;首地址16byte处内存，即赋值vbtable指针
    mov    edx, DWORD PTR _ii$[ebp];获取参数ii的值，给寄存器edx
    push    edx;压栈edx，给虚基类构造函数传递参数
    mov    ecx, DWORD PTR _this$[ebp];将对象b的首地址给寄存器ecx
    add    ecx, 32                    ; 对象b的首地址加上32byte，得到虚基类Top首地址，存放到寄存器ecx，作为隐含参数传递给虚基类构造函数
    call    ??0Top@@QAE@H@Z                ; 调用虚基类构造函数
$LN1@Bottom:
    push    0;压入标志0，用来判断调用Left构造函数时，是否调用虚基类的构造函数
    mov    eax, DWORD PTR _ii$[ebp];将参数ii的值给寄存器eax
    push    eax;压栈eax，为Left构造函数传递参数
    mov    ecx, DWORD PTR _jj$[ebp];获取参数jj的值给寄存器ecx
    push    ecx;压栈ecx，为Left构造函数传递参数
    mov    ecx, DWORD PTR _this$[ebp];获取对象b的首地址(也是父类Left对象的首地址),给寄存器ecx，作为隐含参数传递给Left构造函数
    call    ??0Left@@QAE@HH@Z            ; 调用Left构造函数
    push    0;压入标志0 用来判断调用Right构造函数时，是否调用虚基类Top的构造函数
    mov    edx, DWORD PTR _ii$[ebp];获取参数ii，给寄存器edx
    push    edx;压栈edx，为Right构造函数传递参数
    mov    eax, DWORD PTR _kk$[ebp];获取参数kk，给寄存器eax
    push    eax;压栈eax，为Right构造函数传递参数
    mov    ecx, DWORD PTR _this$[ebp];获取对象b的首地址，给寄存器ecx
    add    ecx, 12                    ; 给对象b的首地址加上12，得到父类Right对象首地址，作为隐含参数传递给Right构造函数
    call    ??0Right@@QAE@HH@Z            ; 调用Right构造函数
    mov    ecx, DWORD PTR _this$[ebp];获取对象b的首地址，给寄存器ecx
    mov    DWORD PTR [ecx], OFFSET ??_7Bottom@@6BLeft@@@;将??_7Bottom@@6BLeft@@@所代表的内存首地址(vftable首地址)写入对象b的首地址处
    mov    edx, DWORD PTR _this$[ebp];获取对象b的首地址
    mov    DWORD PTR [edx+12], OFFSET ??_7Bottom@@6BRight@@@;将??_7Bottom@@6BRight@@@所代表的内存首地址(vftable首地址)写入偏移对象b首地址12byte处
                                                         ;即写到了父类Right对象的首地址处
    mov    eax, DWORD PTR _this$[ebp];获取对象b的首地址，给寄存器eax
    mov    ecx, DWORD PTR [eax+4];获取偏移对象b首地址4byte处内存内容(即vbtable首地址)给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top的虚表指针偏移对象b的vbtable指针的偏移量)，给寄存器edx
    mov    eax, DWORD PTR _this$[ebp];获取对象b的首地址给寄存器eax
    mov    DWORD PTR [eax+edx+4], OFFSET ??_7Bottom@@6BTop@@@;eax存放对象b的首地址，edx存放虚基类Top的虚表指针偏移对象b的vbtable指针的偏移量
                                                          ;两者相加，再加上对象b自身首地址处的vptr指针大小，得到虚基类Top的首地址
                                                          ;将??_7Bottom@@6BTop@@@所代表的内存地址(vftable首地址)写入到虚基类首地址处
    mov    ecx, DWORD PTR _this$[ebp];获取对象b的首地址，给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移对象首地址4byte处内存内容(即vbtable首地址),给寄存器edx
    mov    eax, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内容，即获取虚基类Top虚表指针偏移对象b的vbtable指针的偏移量，给寄存器eax
    sub    eax, 28                    ; 将上述获取的偏移量减28
    mov    ecx, DWORD PTR _this$[ebp];获取对象b的首地址，给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移对象首地址4byte处内存内容(即vbtable首地址),给寄存器edx
    mov    ecx, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内容，即获取虚基类Top虚表指针偏移对象b的vbtable指针的偏移量，给寄存器ecx
    mov    edx, DWORD PTR _this$[ebp];获取对象b的首地址，给寄存器edx
    mov    DWORD PTR [edx+ecx], eax;edx保存对象那个b的首地址，ecx保存的是虚基类Top虚表指针偏移对象b的vbtable指针的偏移量，两者相加，得?
                                ;vtordisp的内存地址(关于vtordisp看文章下面提供的连接),将eax的值写入该内存
                                ;通过下面的内存布局图，可以看到eax的值为0

; 45   :         l = ll;

    mov    eax, DWORD PTR _this$[ebp];获取对象b的首地址，给寄存器eax
    mov    ecx, DWORD PTR _ll$[ebp];获取参数ll，给寄存器ecx
    mov    DWORD PTR [eax+24], ecx;将参数ll的值写入偏移对象b首地址24byte处的内存，即为成员变量l赋值

; 46   :     }

    mov    eax, DWORD PTR _this$[ebp]
    mov    esp, ebp
    pop    ebp
    ret    20                    ; 00000014H
??0Bottom@@QAE@HHHH@Z ENDP                ; Bottom::Bottom

下面是Left构造函数的汇编码:

??0Left@@QAE@HH@Z PROC                    ; Left::Left, COMDAT
; _this$ = ecx

; 16   :     Left(int jj, int ii) : Top(ii) {

    push    ebp
    mov    ebp, esp
    push    ecx;压栈ecx的目的，是为保留类Left的对象首地址预留空间
    mov    DWORD PTR _this$[ebp], ecx;ecx寄存器保留类Left对象首地址，存放到刚才预留的空间
    cmp    DWORD PTR _$initVBases$[ebp], 0;_$initVBases所带表的内存存放着调用Left构造函数之前传入的标志
                                       ;这里将标志与0比较
    je    SHORT $LN1@Left;如果标志为0，则跳到标号$LN1@Left处执行，不会调用虚基类的构造函数，否则，顺序执行，这里跳到标号处执行
    mov    eax, DWORD PTR _this$[ebp];获取类Left对象的首地址，给寄存器eax
    mov    DWORD PTR [eax+4], OFFSET ??_8Left@@7B@;将??_8Left@@7B@所代表的的内存地址(即vbtable的首地址)，写入到偏移类Left对象首地址4byte处
    mov    ecx, DWORD PTR _ii$[ebp];获取参数ii的值，给ecx寄存器
    push    ecx;压栈ecx，为调用虚基类构造函数传递参数
    mov    ecx, DWORD PTR _this$[ebp];获取类Left的首地址，给寄存器ecx
    add    ecx, 16                    ; 将类Left的首地址加上16byte，得到虚基类的首地址，作为隐含参数传递给虚基类的构造函数
    call    ??0Top@@QAE@H@Z                ; 调用虚基类的构造函数
$LN1@Left:
    mov    edx, DWORD PTR _this$[ebp];获取类Left对象的首地址，给寄存器edx
    mov    DWORD PTR [edx], OFFSET ??_7Left@@6B0@@;将??_7Left@@6B0@@所代表的内存地址(即vftable首地址)写入类Left对象首地址处
    mov    eax, DWORD PTR _this$[ebp];获取类Left对象的首地址，给寄存器eax
    mov    ecx, DWORD PTR [eax+4];获取偏移类Left对象首地址4byte处内存内容(即vbtable首地址)给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移vbtable首地址4byte处内存的内容(即虚基类虚表指针偏移vbtable指针的偏移量)，给edx
    mov    eax, DWORD PTR _this$[ebp];获取类Left对象的首地址，给eax寄存器
    mov    DWORD PTR [eax+edx+4], OFFSET ??_7Left@@6BTop@@@;eax寄存器里面存放有类Left对象的首地址，edx存放着虚基类虚表指针偏移vbtable指针的偏移量
                                                        ;两者相加，在加上类Left对象自身的vptr大小4byte，得到虚基类Top的首地址
                                                        ;将??_7Left@@6BTop@@@所带表的内存地址(即vftable首地址)写入到虚基类的首地址处
    mov    ecx, DWORD PTR _this$[ebp];获取类Left对象的首地址，给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移类Left对象的首地址4byte处的内容(即vbtable首地址)，给寄存器edx
    mov    eax, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top虚表指针偏移vbtable指针的偏移量)，给寄存器eax
    sub    eax, 12                    ; eax的值减12，通过调试汇编，或者下面的内存布局可以算出，其值为0
    mov    ecx, DWORD PTR _this$[ebp];获取类Left对象的首地址，给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移类Left对象的首地址4byte处的内容(即vbtable首地址)，给寄存器edx
    mov    ecx, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top虚表指针偏移vbtable指针的偏移量)，给寄存器ecx
    mov    edx, DWORD PTR _this$[ebp];获取类Left对象的首地址，给寄存器edx
    mov    DWORD PTR [edx+ecx], eax;edx寄存器保存这类Left对象的首地址，ecx寄存器保存着虚基类Top虚表指针偏移vbtable指针的偏移量，
                                ;二者相加，得到vtordisp所在内存(关于vtordisp，参看文章下面提供的链接)
                                ;将eax的值写入该内存

; 17   :         j = jj;

    mov    eax, DWORD PTR _this$[ebp];获取类Left对象的首地址，给寄存器eax
    mov    ecx, DWORD PTR _jj$[ebp];将参数jj的值给寄存器ecx
    mov    DWORD PTR [eax+8], ecx;将参数jj的值写入偏移类Left对象首地址8byte处内存，即给成员变量j赋值

; 18   :     }

    mov    eax, DWORD PTR _this$[ebp]
    mov    esp, ebp
    pop    ebp
    ret    12                    ; 0000000cH
??0Left@@QAE@HH@Z ENDP                    

下面是Right构造函数的汇编码:

??0Right@@QAE@HH@Z PROC                    ; Right::Right, COMDAT
; _this$ = ecx

; 30   :     Right(int kk, int ii) : Top(ii) {

    push    ebp
    mov    ebp, esp
    push    ecx;压栈ecx的目的，是为了保存类Right对象的首地址预留空间
    mov    DWORD PTR _this$[ebp], ecx;ecx保存着类Right对象的首地址，存到刚才分配的空间里面
    cmp    DWORD PTR _$initVBases$[ebp], 0;_$initVBases所带表的内存存放着调用Right构造函数之前传入的标志，这里将标志与0比较
    je    SHORT $LN1@Right;如果标志等于0，跳转到标号$LN1@Right执行，不调用虚基类的构造函数，否则，顺序执行。这里跳转到标号执行
    mov    eax, DWORD PTR _this$[ebp];获取类Right对象的首地址，给寄存器eax
    mov    DWORD PTR [eax+4], OFFSET ??_8Right@@7B@;将??_8Right@@7B@所代表的内存地址(即vbtable首地址)写入到偏移类Right对象首地址4byte处内存
    mov    ecx, DWORD PTR _ii$[ebp];获取参数ii，给寄存器ecx
    push    ecx;压栈ecx，为调用虚基类构造函数传递参数
    mov    ecx, DWORD PTR _this$[ebp];获取类Right对象的首地址给寄存器ecx
    add    ecx, 16                    ; 将类Right对象的首地址加16，得到虚基类的首地址，存到寄存器ecx，作为隐含参数传递给虚基类构造函数
    call    ??0Top@@QAE@H@Z                ; 调用虚基类的构造函数
$LN1@Right:
    mov    edx, DWORD PTR _this$[ebp];获取类Right对象的首地址给寄存器edx
    mov    DWORD PTR [edx], OFFSET ??_7Right@@6B0@@;将??_7Right@@6B0@@所代表的内存地址(即vftable的首地址)写入到类Right对象的首地址处
    mov    eax, DWORD PTR _this$[ebp];获取类Right对象的首地址给寄存器eax
    mov    ecx, DWORD PTR [eax+4];获取偏移类Right对象首地址4byte处内存内容(即vbtable首地址),给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类虚表指针偏移vbtable指针的偏移量)，给寄存器edx
    mov    eax, DWORD PTR _this$[ebp];获取类Right对象的首地址给eax寄存器
    mov    DWORD PTR [eax+edx+4], OFFSET ??_7Right@@6BTop@@@;eax寄存器保存类Right对象首地址，edx寄存器保存虚基类虚表指针偏移vbtable指针的偏移量
                                                         ;二者相加，再加上类Right对象自身的vptr大小(4byte)，得到虚基类的首地址
                                                         ;将??_7Right@@6BTop@@@所带表的内存地址(即vftable首地址)写入到虚基类对象的首地址处
    mov    ecx, DWORD PTR _this$[ebp];获取类Right对象的首地址给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移类Right对象首地址4byte处内存内容(即vbtable首地址),给寄存器edx
    mov    eax, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类虚表指针偏移vbtable指针的偏移量)，给寄存器eax
    sub    eax, 12                    ; eax的值减12，通过汇编调试或者内存布局可以发现，其值为0
    mov    ecx, DWORD PTR _this$[ebp];获取类Right对象的首地址给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移类Right对象首地址4byte处内存内容(即vbtable首地址),给寄存器edx
    mov    ecx, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类虚表指针偏移vbtable指针的偏移量)，给寄存器ecx
    mov    edx, DWORD PTR _this$[ebp];获取类Right对象的首地址，给寄存器edx
    mov    DWORD PTR [edx+ecx], eax;寄存器edx里面保存着类Right的首地址，ecx寄存器保存着虚基类虚表指针偏移vbtable指针的偏移量
                                 ;两者相加，得到vtordisp的内存地址(关于vtrodisp参看文章后面的额链接)

; 31   :         k = kk;

    mov    eax, DWORD PTR _this$[ebp];获取类Right对象的首地址，给寄存器eax
    mov    ecx, DWORD PTR _kk$[ebp];获取参数kk的值，给寄存器ecx
    mov    DWORD PTR [eax+8], ecx;将参数的值写入到偏移类Right对象首地址8byte处，即为成员变量k赋值

; 32   :     }

    mov    eax, DWORD PTR _this$[ebp]
    mov    esp, ebp
    pop    ebp
    ret    12                    ; 0000000cH
??0Right@@QAE@HH@Z ENDP                    ; Right::Right

下面是Top构造函数的汇编码:

??0Top@@QAE@H@Z PROC                    ; Top::Top, COMDAT
; _this$ = ecx

; 5    :     Top(int ii) {

    push    ebp
    mov    ebp, esp
    push    ecx;压栈的目的是为了保存虚基类对象的首地址预留空间
    mov    DWORD PTR _this$[ebp], ecx;ecx里面存放虚基类对象的首地址，存放到刚才分配的空间
    mov    eax, DWORD PTR _this$[ebp];获取虚基类对象的首地址，给寄存器eax
    mov    DWORD PTR [eax], OFFSET ??_7Top@@6B@;将??_7Top@@6B@所代表的的内存地址，即vftale首地址，写入虚基类对象首地址处

; 6    :         i = ii;

    mov    ecx, DWORD PTR _this$[ebp];获取虚基类对象首地址的值，给寄存器ecx
    mov    edx, DWORD PTR _ii$[ebp];获取参数ii的值，给寄存器edx
    mov    DWORD PTR [ecx+4], edx;将参数ii的值写入偏移虚基类对象首地址4byte处，即给成员变量i赋值

; 7    :     }

    mov    eax, DWORD PTR _this$[ebp]
    mov    esp, ebp
    pop    ebp
    ret    4
??0Top@@QAE@H@Z ENDP                    ; Top::Top

下面是类的继承关系图:

下面是4个类的内存布局:

关于Left Right 和Bottom中的vtordisp，请参看链接《关于vtrodisp知多少》

上面的内存布局也看以通过cmd命令行来查看，查看方法请参考链接《c++中如何查看一个类的内存布局》。有了它，对于其他类型的虚继承以及任何类的内存布局，都可以自行分析。例如：查看Bottom的内存布局，结果如下:

从Bottom的内存布局我们可以发现，其对象含有2个vbtable指针，3个vptr指针。其中第一个vptr指针为类Bottom对象和父类Left子对象共享，其vftable存储的是类Bottom和类Left的虚函数地址(不包括继承自虚基类);而第二个vptr指针指向的vftable存储的是类Right的虚函数地址(不包括继承自虚函数)。第三个vptr指向的vtable存储的是虚基类自己的虚函数。有了这些指针，就可以合理的运用多态，调用虚函数。

从main函数的汇编码中，我们还可以发现，当调用虚函数，作为隐含参数传递的this指针(由ecx传递)并不都是实际的对象首地址,而传递的是当前被调用虚函数原来所在类的首地址。比如main函数里面的这一段汇编码:

; 76   :     int btop = bp->getTop();

    mov    ecx, DWORD PTR _bp$[ebp];获取对象b的首地址给寄存器ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移对象首地址4字节处的内存内容(即vbtable首地址)给寄存器edx
    mov    eax, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top虚表指针偏移对象b的vbtable指针的偏移量),写入寄存器eax
    mov    ecx, DWORD PTR _bp$[ebp];获取对象b的首地址ecx
    mov    edx, DWORD PTR [ecx+4];获取偏移对象首地址4字节处的内存内容(即vbtable首地址)给寄存器edx
    mov    ecx, DWORD PTR [edx+4];获取偏移vbtable首地址4byte处内存内容(即虚基类Top虚表指针偏移对象b的vbtable指针的偏移量),写入寄存器ecx
    mov    edx, DWORD PTR _bp$[ebp];获取对象b首地址给寄存器edx
    lea    ecx, DWORD PTR [edx+ecx+4];edx里面保存有对象b的首地址，ecx里面保存虚基类Top虚表指针到对象b的vbtable指针的偏移量
                                  ;二者相加，再加上对象b自身的vptr指针大小4byte，得到虚基类Top首地址，存放到寄存器ecx
    mov    edx, DWORD PTR _bp$[ebp];获取对象b的首地址，给寄存器edx
    mov    eax, DWORD PTR [edx+eax+4];edx里面保存有对象b的首地址，eax里面保存虚基类Top虚表指针到对象b的vbtable指针的偏移量
                                  ;二者相加，再加上对象b自身的vptr指针大小4byte，得到虚基类Top首地址，存放到寄存器eax
    mov    edx, DWORD PTR [eax];获取虚基类首地址处内容(即vftable首地址)给寄存器eax，即虚函数getTop首地址
    call    edx;调用虚函数getTop
    mov    DWORD PTR _btop$[ebp], eax;eax保存函数getTop调用的返回结果，存放到btop变量

bp调用虚函数，而传递的隐含参数(this指针，由ecx寄存器传递，也就是上面助记符为lea所在代码)是虚基类Top对象的首地址。所以，当在getTop函数里面需要操作this指针时，都会有一个this指针的转换操作，使this指针指向调用当前虚函数的实际对象首地址。这个转换的值就是上面用cmd查看Bottom内存布局时最后4行显示的结果，它们存储在相应的虚表里，从上面的查看结果也可以看到。