从汇编看c++中的多态

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

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

　　c++源码：

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();//用指针间接调用
}

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();//用指针间接调用
}

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

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

; 25   :  y.f();

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

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

; 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

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

　　继承和vtable

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

　　下面是c++源码：

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();编译器报错
}

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

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

; 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();