来自 计算机网络 2019-11-13 19:20 的文章
当前位置: 六合联盟网 > 计算机网络 > 正文

从汇编看c,中的多态

从汇编看c++函数的默认参数,汇编

在c++中,可以为函数提供默认参数,这样,在调用函数的时候,如果不提供参数,编译器将为函数提供参数的默认值。下面从汇编看其原理。

下面是c++源码:

图片 1

int add(int a = 1, int b = 2) {//参数a b有默认值
    return a + b;
}
int main() {
   int c= add();//不提供参数

}

图片 2

下面是mian函数里面的汇编码:

图片 3

; 4    : int main() {

    push    ebp
    mov    ebp, esp
    push    ecx;为局部变量c分配了4字节的存储空间 ecx为32位寄存器

; 5    :    int c= add();

    push    2;将2压栈,就是add函数中b参数的默认值 这里参数压栈方向是从右向左
    push    1;将1压栈,就是add函数中a参数的默认值
    call    ?add@@[email protected]                ; 调用add函数
    add    esp, 8;释放刚才为add提供参数时的储存空间
    mov    DWORD PTR _c$[ebp], eax;eax寄存器里面存放add函数返回值,写入变量c里面

; 6    :    
; 7    : }

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

图片 4

下面是add函数的汇编码:

图片 5

?add@@[email protected] PROC                    ; add

; 1    : int add(int a = 1, int b = 2) {

    push    ebp
    mov    ebp, esp

; 2    :     return a + b;

    mov    eax, DWORD PTR _a$[ebp];将参数a的值写入寄存器eax
    add    eax, DWORD PTR _b$[ebp];将参数b的值取出与eax里面的值相加,结果存入eax寄存器

; 3    : }

    pop    ebp
    ret    0
?add@@[email protected] ENDP    

图片 6

下面是只提供一个参数值得情况

先看c++源码:

图片 7

int add(int a = 1, int b = 2) {//参数a b有默认值
    return a + b;
}
int main() {
   int a = 3;
   int c= add(a);//只为a提供参数

}

图片 8

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

图片 9

; 4    : int main() {

    push    ebp
    mov    ebp, esp
    sub    esp, 8;esp寄存器作为栈指针移动8字节,为局部变量a,c预留存储空间

; 5    :    int a = 3;

    mov    DWORD PTR _a$[ebp], 3;将3写入局部变量a所在存储空间

; 6    :    int c= add(a);//不提供参数

    push    2;将2压栈,提供b参数默认值
    mov    eax, DWORD PTR _a$[ebp];取出a的值,放入寄存器eax里面
    push    eax;将eax里面的值压栈,提供参数a的值,这里不是提供的默认值1
    call    ?add@@[email protected]                ; 调用add函数
    add    esp, 8;释放刚才为调用函数add为参数分配的8byte空间
    mov    DWORD PTR _c$[ebp], eax;eax里面存放调用函数的结果,写到c所在存储空间里面

; 7    :    
; 8    : }

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

图片 10

可以看到,和上面的不同之处在于没有为a提供默认的参数值。

下面是add函数的汇编码,与第一种情况一样,没有变化:

图片 11

?add@@[email protected] PROC                    ; add

; 1    : int add(int a = 1, int b = 2) {//参数a b有默认值

    push    ebp
    mov    ebp, esp

; 2    :     return a + b;

    mov    eax, DWORD PTR _a$[ebp]
    add    eax, DWORD PTR _b$[ebp]

; 3    : }

    pop    ebp
    ret    0
?add@@[email protected] ENDP

图片 12

这里由于为参数a给出了明确的值,因此编译器只为参数b提供默认值。可想而知,若为add函数都提供了明确的参数值,那么编译器就不会为参数a,b提供默认值了。

 

 

在c++中,可以为函数提供默认参数,这样,在调用函数的时候,如果不提供参数,编译器将为函数提供参...

在c++中,当一个类含有虚函数的时候,类就具有了多态性。构造函数的一项重要功能就是初始化vptr指针,这是保证多态性的关键步骤。

构造函数初始化vptr指针

下面是c++源码:

图片 13

class X {
private:
    int i;
public:
    X(int ii) {
        i = ii;
    }
    virtual void set(int ii) {//虚函数
        i = ii;
    }
};




int main() {
   X x(1);
}

图片 14

下面是对应的main函数汇编码:

图片 15

_main    PROC

; 16   : int main() {

    push    ebp
    mov    ebp, esp
    sub    esp, 8;为对象x预留8byte空间 vptr指针占4字节 成员变量i占4byte

; 17   :    X x(1);

    push    1;//将1压栈,作为参数传递给构造函数
    lea    ecx, DWORD PTR _x$[ebp];//获取x的首地址,即this指针,作为隐含参数传递给构造器
    call    ??0X@@QAE@H@Z                ; 为x调用构造器

; 18   : }

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

图片 16

从汇编码可以看到,由于类X具有虚函数,main函数在栈上为对象x预留了8byte的空间,用来存放vptr指针和成员变量i。

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

图片 17

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

; 5    :     X(int ii) {

    push    ebp
    mov    ebp, esp
    push    ecx;压栈ecx的目的是为了给this指针(x对象首地址)预留4byte的空间
    mov    DWORD PTR _this$[ebp], ecx;将this指针存储到刚才预留的空间里 ecx里面存放了x的首地址
    mov    eax, DWORD PTR _this$[ebp];将x的首地址给寄存器eax
    mov    DWORD PTR [eax], OFFSET ??_7X@@6B@;将??_7X@@6B@的偏移地址(即vtable的首地址)放到x对象的首地址指向的内存储 这里就是初始化vptr指针

; 6    :         i = ii;

    mov    ecx, DWORD PTR _this$[ebp];将x首地址给ecx
    mov    edx, DWORD PTR _ii$[ebp];将参数ii的值给寄存器edx
    mov    DWORD PTR [ecx+4], edx;将寄存器eax的值写入偏移x首地址4byte处的内存,即给x的成员变量i赋值

; 7    :     }

    mov    eax, DWORD PTR _this$[ebp];将x对象首地址给寄存器eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    4
??0X@@QAE@H@Z ENDP        

图片 18

从代码中可以看出来,编译器确实暗中插入了代码,来用vtable的首地址初始化vptr指针,并且vptr指针位于对象首地址处。

如果类有继承关系,构造函数又如何初始化vptr指针呢?

下面是c++源码:

图片 19

class X {
private:
    int i;
public:
    virtual void f() {}
};

class Y : public X {//Y继承自X
private:
   int j;
};




int main() {
 Y y;
}

图片 20

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

图片 21

_main    PROC

; 16   : int main() {

    push    ebp
    mov    ebp, esp
    sub    esp, 12                    ; 为对象y预留12 byte的空间 vptr指针4byte 父类成员变量4byte 子类成员变量4byte

; 17   :  Y y;

    lea    ecx, DWORD PTR _y$[ebp];获取对象y的首地址(即this指针),作为隐含参数传递给构造函数
    call    ??0Y@@QAE@XZ;调用y的构造函数 虽然y没有显示定义构造函数,但由于其含有虚成员函数,编译器提供默认构造函数

; 18   : }

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

图片 22

下面是子类构造函数汇编码:

图片 23

??0Y@@QAE@XZ PROC                    ; Y::Y, COMDAT
; _this$ = ecx
    push    ebp
    mov    ebp, esp
    push    ecx;//压栈ecx的目的是存放this指针
    mov    DWORD PTR _this$[ebp], ecx;将this指针(即对象首地址)放到刚才预留空间 ecx里面存放对象首地址
    mov    ecx, DWORD PTR _this$[ebp];将对象首地址给ecx 作为隐含参数传递给父类构造函数
    call    ??0X@@QAE@XZ;调用父类构造函数
    mov    eax, DWORD PTR _this$[ebp];将y的首地址给寄存器eax
    mov    DWORD PTR [eax], OFFSET ??_7Y@@6B@;将y的vtable(??_7Y@@6B@)首地址赋给y对象首地址所指内存 即初始化子类vptr指针
    mov    eax, DWORD PTR _this$[ebp];将y首地址给eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    0
??0Y@@QAE@XZ ENDP    

图片 24

下面是父类构造函数汇编码:

图片 25

??0X@@QAE@XZ PROC                    ; X::X, COMDAT
; _this$ = ecx
    push    ebp
    mov    ebp, esp
    push    ecx;压栈的目的是为了存放this指针(父对象对象首地址)预留空间
    mov    DWORD PTR _this$[ebp], ecx;将父对象对象首地址(ecx中保存)放入刚才预留空间
    mov    eax, DWORD PTR _this$[ebp];将父对象首地址给寄存器eax
    mov    DWORD PTR [eax], OFFSET ??_7X@@6B@;将vtable(??_7X@@6B@ 和子类不同)首地址赋给父对象首地址处的内存 即初始化父对象的vptr指针
    mov    eax, DWORD PTR _this$[ebp];将父对象的首地址传给eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    0
??0X@@QAE@XZ ENDP

图片 26

从上面子类和父类的构造函数汇编码可以看出来,子对象包含父对象,在构造子对象的时候先构造父对象(子对象构造函数先调用父对象构造函数)。而且父对象的首地址和子对象的首地址一样(通过汇编码中ecx传递的值可以看出来),因此父对象和子对象的vptr指针位于同一处。所以,在构造对象的构成中,vptr指针先被初始化指向父对象的vtable首地址(在父对象构造函数中),最后又被初始化为指向子对象的vtable首地址(在子对象的构造函数中)。因此,在涉及继承的时候,vptr指针的值由最后调用的构造函数决定。

在构造函数调用虚函数机制失效,也就是说,在构造函数中调用虚函数总是本地版本(析构函数中也是一样)

c++源码如下:

图片 27

class X {
private:
    int i;
public:
    virtual void f(int ii) {
        i = ii;
    }
    X() {
       f(1);
    }
};

class Y : public X {//Y继承自X
private:
   int j;
public:
    virtual void f(int ii) {
        j = ii;
    }
    Y() {
        f(2);
    }
};




int main() {
 Y y;
}

图片 28

 下面主要来看父类X和子类Y中的构造函数的汇编码:

子类Y的构造函数汇编码:

图片 29

??0Y@@QAE@XZ PROC                    ; Y::Y, COMDAT
; _this$ = ecx

; 20   :     Y() {

    push    ebp
    mov    ebp, esp
    push    ecx;压栈的目的是为存放this指针(在ecx寄存器里面存放了子对象首地址)预留空间
    mov    DWORD PTR _this$[ebp], ecx;将子对象首地址存入刚才预留空间
    mov    ecx, DWORD PTR _this$[ebp];将子类首地址作为隐含参数传给父对象构造器(子对象首地址和父对象首地址一样)
    call    ??0X@@QAE@XZ                ; 调用父类构造器
    mov    eax, DWORD PTR _this$[ebp];将子对象首地址传给寄存器eax
    mov    DWORD PTR [eax], OFFSET ??_7Y@@6B@;将子对象的vtable首地址存到子对象首地址所指向的内存,即初始化子对象的vptr指针

; 21   :         f(2);

    push    2;将2压栈,作为参数调用函数f,这里,子对象调用的是自己的函数f
    mov    ecx, DWORD PTR _this$[ebp];将子对象首地址传给ecx,作为隐含参数传递给成员函数f
    call    ?f@Y@@UAEXH@Z                ; 调用子对象中的f函数

; 22   :     }

    mov    eax, DWORD PTR _this$[ebp];将子对象首地址给寄存器eax,作为返回值。构造器总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    0
??0Y@@QAE@XZ ENDP                    ; Y::Y

图片 30

父类X构造函数的汇编码:

图片 31

??0X@@QAE@XZ PROC                    ; X::X, COMDAT
; _this$ = ecx

; 8    :     X() {

    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 ??_7X@@6B@;将父对象的vtable首地址写入父对象首地址所指向的内存 即初始化父对象的vptr指针

; 9    :        f(1);

    push    1;将1压栈,作为参数调用函数f 这里调用时父对象的版本
    mov    ecx, DWORD PTR _this$[ebp];将父对象首地址作为隐含参数传给f
    call    ?f@X@@UAEXH@Z                ; 调用函数f

; 10   :     }

    mov    eax, DWORD PTR _this$[ebp];将父对象首地址传给eax作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    0
??0X@@QAE@XZ ENDP        

图片 32

从汇编码中可以看到,构造函数中确实不存在虚机制,都只调用本地版本的函数

析构函数

析构函数在执行的时候,会先将vptr指针初始化为当前类的虚表vtable首地址,但是如果析构函数时编译器提供非无用的默认析构函数,则不会有vptr指针的初始化操作:

c++源码:

 

图片 33

class X {
private:
    int i;
public:
    virtual void set(int ii) {
        i = ii;
    }
    ~X() {}
};
class Y : public X {
private:
    int i;
};
int main() {
    Y y;
}

图片 34

类Y析构函数汇编码:

 

图片 35

??1Y@@QAE@XZ PROC                    ; Y::~Y, COMDAT
; _this$ = ecx
    push    ebp
    mov    ebp, esp
    push    ecx;为传进来的y对象首地址预留空间
    mov    DWORD PTR _this$[ebp], ecx;ecx中保存y对象首地址,存到刚才空间中
    mov    ecx, DWORD PTR _this$[ebp];将y对象首地址(y对象包含父对象,他们的首地址一样)传给ecx,作为隐含参数传地址类X的析构函数
    call    ??1X@@QAE@XZ                ; 调用类X的析构函数
    mov    esp, ebp
    pop    ebp
    ret    0
??1Y@@QAE@XZ ENDP

图片 36

从汇编码可以看到,编译器为y对象提供了非无用的默认析构函数,用来调用父类的析构函数,但是在y对象的析构函数里面,并没有初始化y对象vptr指针指向类Y的虚表vtable的操作。

下面是类X的析构函数汇编码:

 

图片 37

??1X@@QAE@XZ PROC                    ; X::~X, COMDAT
; _this$ = ecx

; 9    :     ~X() {}

    push    ebp
    mov    ebp, esp
    push    ecx;为传进来的父对象的首地址预留空间
    mov    DWORD PTR _this$[ebp], ecx;为将传进来的父对象首地址存放到刚才空间
    mov    eax, DWORD PTR _this$[ebp];父对象首地址给eax
    mov    DWORD PTR [eax], OFFSET ??_7X@@6B@;将父类vtable首地址给父对象首地址处的内存 即初始化父对象中的vptr指针
    mov    esp, ebp
    pop    ebp
    ret    0
??1X@@QAE@XZ ENDP    

图片 38

父类的析构函数有初始化vptr的操作,此时的vptr所指向的虚表已经是类X所对应的虚表,而不是子类Y对应的虚表。

 

抽象基类

c++源码如下:

图片 39

class X {
private:
    int i;
public:
    virtual void f() = 0;//纯虚函数
    X() {
       i = 1;
    }
};

class Y : public X {//Y继承自X
private:
   int j;
public:
    virtual void f() {
        j = 2;
    }
};




int main() {
 Y y;
}

图片 40

只看父类X的构造函数和子类Y的构造函数的汇编码:
子类Y构造函数的汇编码:

图片 41

??0Y@@QAE@XZ PROC                    ; Y::Y, COMDAT
; _this$ = ecx
    push    ebp
    mov    ebp, esp
    push    ecx;为保存子对象首地址预留空间 
    mov    DWORD PTR _this$[ebp], ecx;将ecx(里面存放子对象首地址)的值放到刚才的空间
    mov    ecx, DWORD PTR _this$[ebp];将子对象首地址传给ecx,作为隐含参数(this指针)调用父对象的构造函数
    call    ??0X@@QAE@XZ                ; 调用父对象的构造函数
    mov    eax, DWORD PTR _this$[ebp];将子对象首地址给eax t
    mov    DWORD PTR [eax], OFFSET ??_7Y@@6B@;将子对象的vtable首地址存到子对象首地址所指向的内存,即初始化子对象的vptr
    mov    eax, DWORD PTR _this$[ebp];将子对象的首地址给eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    0
??0Y@@QAE@XZ ENDP            

图片 42

父类X构造函数汇编码:

图片 43

??0X@@QAE@XZ PROC                    ; X::X, COMDAT
; _this$ = ecx

; 6    :     X() {

    push    ebp
    mov    ebp, esp
    push    ecx;压栈的目的就是为存储父对象首地址(即this指针)预留空间
    mov    DWORD PTR _this$[ebp], ecx;将父对象首地址存到刚才的空间
    mov    eax, DWORD PTR _this$[ebp];将父对象的首地址传给eax
    mov    DWORD PTR [eax], OFFSET ??_7X@@6B@;将父对象的vtable(由于父类为抽象类,其vtable不完全,即里面没有存放纯虚函数的地址,只为其保留了一个位置)首地址存到父对象首地址所指的内存 即初始化父对象的vptr指针

; 7    :        i = 1;

    mov    ecx, DWORD PTR _this$[ebp];将父对象的首地址给ecx
    mov    DWORD PTR [ecx+4], 1;将1存到偏移父对象首地址4byte处,即给父对象的成员变量i赋值

; 8    :     }

    mov    eax, DWORD PTR _this$[ebp];父对象的首地址给eax 作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    0
??0X@@QAE@XZ ENDP

图片 44

从汇编码可以看出,在构造子类的过程中,依然调用了父类的构造函数,尽管父类是一个抽象类。但这只是为了初始化子对象中包含父对象的部分,如果直接想从父类实例化一个对象,编译器报错,这是因为父类的vtable不完全,编译器不能安全的创建一个抽象类对象。而在构造子对象的构成当中,虽然在构造子对象中所包含的的父对象部分,vptr暂时指向了父类的vtable,但是,当子对象构造完成时,vptr最终指向了子类的vtable。子类的vtable是一个完整的,因此编译器允许。

多态的晚捆绑机制只有在用地址或者引用调用虚函数的时候才有效,如果用对象本身直接调用虚函数,则不会出现晚捆绑,而是直接调用。

c++源码:

图片 45

class X {
private:
    int i;
public:
    virtual void f() {
        i = 1;
    }
};

class Y : public X {//Y继承自X
private:
   int j;
public:
    virtual void f() {
        j = 2;
    }
};




int main() {
 Y y;//栈上创建对象
 Y* yp = new Y;//堆上创建对象
 y.f();//用对象直接调用
 yp->f();//用指针间接调用
}

图片 46

图片 47

class X {
private:
    int i;
public:
    virtual void f() {
        i = 1;
    }
};

class Y : public X {//Y继承自X
private:
   int j;
public:
    virtual void f() {
        j = 2;
    }
};




int main() {
 Y y;//栈上创建对象
 Y* yp = new Y;//堆上创建对象
 y.f();//用对象直接调用
 yp->f();//用指针间接调用
}

图片 48

主要来看用对象直接调用函数f和用指针调用函数f的汇编码:

用对象直接调用函数f的汇编码:

; 25   :  y.f();

    lea    ecx, DWORD PTR _y$[ebp];将栈上创建的对象y的首地址给ecx,作为隐含参数传递给f
    call    ?f@Y@@UAEXXZ                ; 用绝对地址调用f

用指针间接调用函数f的汇编码:

图片 49

; 26   :  yp->f();

    mov    ecx, DWORD PTR _yp$[ebp];将yp指针指向的堆对象的首地址给ecx
    mov    edx, DWORD PTR [ecx];将堆上创建的对象首地址所指向的内容给edx 即将vptr指针指向的vtable首地址给edx
    mov    ecx, DWORD PTR _yp$[ebp];将yp指针指向的堆对象的首地址给ecx 作为隐含参数传递给要调用的函数f
    mov    eax, DWORD PTR [edx];edx存的是vtable首地址,这里取vtable首地址的内容给eax 即函数f的地址给eax
    call    eax;调用eax

图片 50

从汇编码中可以看出,用对象直接调用的时候根本没有访问虚表vtable,只有用指针调用的时候才会访问vtable,形成晚捆绑。因为用对象直接调用的时候,编译器已经知道了对象的确切类型,为了提高效率,当调用这些虚函数的时候,使用了造捆绑。

继承和vtable

当子类继承父类时,编译器为子类重新创建一个vtable,并且父类中的虚函数在父类vatelbe中的位置准确的映射到子类vtable中的同样位置,对于子类中重新定义的虚函数,将在子类vtable的新位置插入其地址。

下面是c++源码:

 

图片 51

class X {
private:
    int i;
public:
    virtual void a() {
        i = 1;
    }
    virtual void b() {
        i = 2;
    }
};

class Y : public X {
private:
    int i;
public:
    virtual void c() {//新定义的虚函数
        i = 3;
    }
    void b() {//重写父类中的虚函数
        i = 4;
    }
};

int main() {
    X* xp = new X;
    X* yp = new Y;
    xp->a();
    xp->b();
    yp->a();
    yp->b();
    //yp->c();编译器报错
}

图片 52

可以看到,用yp指针调用子类中的虚函数c,编译器报错。这是因为尽管yp指针所指向的时机类型是子类Y,但是由于向上转型为基类X类型,因此,编译器在编译的时候只针对基类,而基类只有虚函数a,b,所以不允许调用子类中的虚函数c。

下面只给出调用虚函数时的汇编代码:

 

图片 53

; 28   :     xp->a();

    mov    edx, DWORD PTR _xp$[ebp];将xp所指向的堆对象首地址给edx
    mov    eax, DWORD PTR [edx];将堆对象首地址里面的内容给eax,即将vptr指向的vtable首地址给eax
    mov    ecx, DWORD PTR _xp$[ebp];将xp所指向的堆对象首地址给ecx,作为隐含参数传递给即将调用的虚成员函数
    mov    edx, DWORD PTR [eax];将vtable首地址里面的内容给edx,即将虚函数a的地址给edx(这里,虚函数a的地址位于父类X的vtable首地址处)
    call    edx;调用虚成员函数a

; 29   :     xp->b();

    mov    eax, DWORD PTR _xp$[ebp];将xp所指堆对象的首地址给eax
    mov    edx, DWORD PTR [eax];将堆对象首地址的内容给edx,即将vptr指向的vtable首地址给edx
    mov    ecx, DWORD PTR _xp$[ebp];将xp所指堆对象的首地址给ecx
    mov    eax, DWORD PTR [edx+4];将偏移vtable首地址4byte处内存内容给eax,即将虚函数b的地址给eax(这里,虚函数b的地址位于偏移父类X的vtable首地址4byte处)
    call    eax;调用虚成员函数b

; 30   :     yp->a();

    mov    ecx, DWORD PTR _yp$[ebp];将yp所指向的堆对象的首地址给ecx
    mov    edx, DWORD PTR [ecx];将堆对象首地址的内容给edx,即将子类vptr指向的vtable首地址给edx
    mov    ecx, DWORD PTR _yp$[ebp];将yp所指向的堆对象首地址给ecx,作为隐含参数传递给虚成员函数a
    mov    eax, DWORD PTR [edx];将子类vtable首地址处的内容给eax,即将虚函数a的地址给eax(这里,虚函数a的地址同样位于子类Y的vtable首地址处)
    call    eax;调用虚成员函数a

; 31   :     yp->b();

    mov    ecx, DWORD PTR _yp$[ebp];将yp所指向的堆对象的首地址给ecx
    mov    edx, DWORD PTR [ecx];将堆对象首地址的内容给edx,即将子类vptr指向的vtable首地址给edx
    mov    ecx, DWORD PTR _yp$[ebp];将yp所指向的堆对象首地址给ecx,作为隐含参数传递给虚成员函数b
    mov    eax, DWORD PTR [edx+4];将偏移子类vtable首地址4byte处内存的内容给eax,即将虚函数b的地址给eax(这里,虚函数b的地址同样位于偏移子类Y的vtable首地址4byte处)
    call    eax;调用虚成员函数b
; 32   :     //yp->c();

图片 54

从汇编码可以看出,a,b虚函数在子类vtable和父类table中的位置是一样的(从它们相对于自己所在vtable的偏移量可以看出)。这就保证了不论对象实际的类型是什么,编译器总能使用同样的偏移量来调用虚函数。假如不这么做,也就是说虚函数a,b在子类Y的vtable中的位置和在父类X的vtable中的位置不一样,由于向上转型,编译器只针对父类工作,也就是对虚函数a,b的调用只会根据父类X的vtable来确定偏移量,那么在实际运行的时候就会出错,实际的子对象根本调用不到正确的函数,多态失效。

在上面的例子中,如果将yp转为实际的类型调用c,我们会看到编译器形成的偏移量为8byte,汇编代码如下:

图片 55

; 32   :     yp->c();

    mov    ecx, DWORD PTR _yp$[ebp];将yp所指向的堆对象的首地址给ecx
    mov    edx, DWORD PTR [ecx];将堆对象首地址的内容给edx,即将子类vptr指向的vtable首地址给edx
    mov    ecx, DWORD PTR _yp$[ebp];将yp所指向的堆对象首地址给ecx,作为隐含参数传递给虚成员函数c
    mov    eax, DWORD PTR [edx+8];将偏移子类vtable首地址8byte处内存的内容给eax,即将虚函数c的地址给eax(这里,虚函数b的地址同样位于偏移子类Y的vtable首地址8byte处)
    call    eax;调用虚成员函数c

图片 56

对象切片

如果进行向上转型的时候不是用传地址或者引用,而是用传值,那么就会发生对象切片,即派生类对象中原有的部分被切除,只保留了基类的部分。

下面是c++源码:

图片 57

class X {
private:
    int i;
public:
    virtual void a() {
        i = 1;
    }
    virtual void b() {
        i = 2;
    }
};

class Y : public X {
private:
    int i;
public:
    virtual void c() {//新定义的虚函数
        i = 3;
    }
    void b() {//重写父类中的虚函数
        i = 4;
    }
};
void f(X x) {//用传值的形式进行向上转换
    x.b();
}

int main() {
    Y y;
    f(y);
}

图片 58

下面是main函数的汇编码:

图片 59

; 28   : int main() {

    push    ebp
    mov    ebp, esp
    sub    esp, 16                    ; 为对象y预留16byte的空间

; 29   :     Y y;

    lea    ecx, DWORD PTR _y$[ebp];将y的首地址给ecx,转为隐含参数传递给y的构造函数
    call    ??0Y@@QAE@XZ;调用y的构造函数

; 30   :     f(y);

    sub    esp, 8;//由于对象传值,要进行拷贝,产生临时对象,这里为临时对象预留8byte的空间(类X的大小)
    mov    ecx, esp;//将临时对象的首地址给ecx,作为隐含参数传递给拷贝函数
    lea    eax, DWORD PTR _y$[ebp];将对象y的首地址给eax,作为参数给拷贝函数
    push    eax;压栈,传递参数
    call    ??0X@@QAE@ABV0@@Z;调用类X的拷贝函数
    call    ?f@@YAXVX@@@Z                ; 调用函数f
    add    esp, 8;释放刚才的临时对象占用的8byte空间
; 31   : }

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

图片 60

从汇编吗中可以看出,临时对象的大小为父类X的大小,调用的拷贝函数也是父类X的拷贝函数。

下面是父类X的拷贝函数汇编码:

图片 61

??0X@@QAE@ABV0@@Z PROC                    ; X::X, COMDAT
; _this$ = ecx
    push    ebp
    mov    ebp, esp
    push    ecx;压栈,为存对象首地址预留4byte空间
    mov    DWORD PTR _this$[ebp], ecx;ecx中保存临时对象首地址,放到刚才预留的空间
    mov    eax, DWORD PTR _this$[ebp];将临时对象首地址给ecx
    mov    DWORD PTR [eax], OFFSET ??_7X@@6B@;将类X的vtable首地址存到临时对象首地址所指向的内存 即初始化临时对象的vptr指针
    mov    ecx, DWORD PTR _this$[ebp];将临时对象的首地址给ecx
    mov    edx, DWORD PTR ___that$[ebp];将y的首地址给edx
    mov    eax, DWORD PTR [edx+4];将偏移y首地址4byte处内存内容给edx,即将y包含的父对象中的成员变量i的值给edx
    mov    DWORD PTR [ecx+4], eax;将eax的值给偏移临时对象首地址4byte处内存,即将eax的值给临时对象的成员变量i
    mov    eax, DWORD PTR _this$[ebp];将临时对象的首地址给eax,作为返回值。构造函数总是返回对象首地址
    mov    esp, ebp
    pop    ebp
    ret    4

图片 62

从拷贝函数可以看出,临时对象只拷贝了y的所包含的的父对象部分(y被切片了),并且临时对象的vptr指针也初始化为类X的vtable首地址。

下面是函数f的汇编码:

图片 63

; 24   : void f(X x) {

    push    ebp
    mov    ebp, esp

; 25   :     x.b();

    lea    ecx, DWORD PTR _x$[ebp];将参数x的首地址给ecx,作为隐含参数传递给成员函数b
    call    ?b@X@@UAEXXZ                ; 调用x中的成员函数b 这里是用对象直接调用,因此没有访问vtable

图片 64

这里调用的是类X里面的成员函数,并且没有访问虚表vtable

下面是类X里面的虚成员函数b的汇编码:

图片 65

?b@X@@UAEXXZ PROC                    ; X::b, COMDAT
; _this$ = ecx

; 8    :     virtual void b() {

    push    ebp
    mov    ebp, esp
    push    ecx;为保存对象首地址预留4byte空间
    mov    DWORD PTR _this$[ebp], ecx;ecx中保存有对象x的首地址,放到刚才预留的空间

; 9    :         i = 2;

    mov    eax, DWORD PTR _this$[ebp];将x首地址给eax
    mov    DWORD PTR [eax+4], 2;将2写给偏移x首地址4byte处,即将2赋给x的成员变量i

; 10   :     }

    mov    esp, ebp
    pop    ebp
    ret    0
?b@X@@UAEXXZ ENDP    

图片 66

 

本文由六合联盟网发布于计算机网络,转载请注明出处:从汇编看c,中的多态

关键词: