从汇编看c++中的多态
添加时间:2013-5-20 点击量:
在c++中，当一个类含有虚函数的时辰，类就具有了多态性。机关函数的一项首要功能就是初始化vptr指针，这是包管多态性的关键步调。
机关函数初始化vptr指针
下面是c++源码:
class X {
private:
int i;
public:
X（int ii） {
i = ii;
}
virtual void set（int ii） {//虚函数
i = ii;
}
};
int main（） {
X x（1）;
}
下面是对应的main函数汇编码:
_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
从汇编码可以看到，因为类X具有虚函数，main函数在栈上为对象x预留了8byte的空间，用来存放vptr指针和成员变量i。
下面是x的机关函数的汇编码:
？？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
从代码中可以看出来，编译器确切暗中插入了代码，来用vtable的首地址初始化vptr指针，并且vptr指针位于对象首地址处。
若是类有持续关系，机关函数又如何初始化vptr指针呢？
下面是c++源码:
class X {
private:
int i;
public:
virtual void f（） {}
};
class Y : public X {//Y持续自X
private:
int j;
};
int main（） {
Y y;
}
下面是main函数中的汇编码:
_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
下面是子类机关函数汇编码:
？？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
下面是父类机关函数汇编码:
？？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
从上面子类和父类的机关函数汇编码可以看出来，子对象包含父对象，在机关子对象的时辰先机关父对象（子对象机关函数先调用父对象机关函数）。并且父对象的首地址和子对象的首地址一样（经由过程汇编码中ecx传递的值可以看出来），是以父对象和子对象的vptr指针位于同一处。所以，在机关对象的构成中，vptr指针先被初始化指向父对象的vtable首地址（在父对象机关函数中），最后又被初始化为指向子对象的vtable首地址（在子对象的机关函数中）。是以，在涉及持续的时辰，vptr指针的值由最后调用的机关函数决意。
在机关函数调用虚函数机制失效，也就是说，在机关函数中调用虚函数老是本地版本（析构函数中也是一样）
c++源码如下:
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;
}
下面首要来看父类X和子类Y中的机关函数的汇编码:
子类Y的机关函数汇编码:
？？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
父类X机关函数的汇编码:
？？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
从汇编码中可以看到，机关函数中确切不存在虚机制，都只调用本地版本的函数
析构函数
析构函数在履行的时辰，会先将vptr指针初始化为当前类的虚表vtable首地址，然则若是析构函数时编译器供给非无用的默认析构函数，则不会有vptr指针的初始化操纵:
c++源码:
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;
}
类Y析构函数汇编码:
？？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
从汇编码可以看到，编译器为y对象供给了非无用的默认析构函数，用来调用父类的析构函数，然则在y对象的析构函数里面，并没有初始化y对象vptr指针指向类Y的虚表vtable的操纵。
下面是类X的析构函数汇编码:
？？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
父类的析构函数有初始化vptr的操纵。
抽象基类
c++源码如下:
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;
}
只看父类X的机关函数和子类Y的机关函数的汇编码:
子类Y机关函数的汇编码:
？？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
父类X机关函数汇编码:
？？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
从汇编码可以看出，在机关子类的过程中，依然调用了父类的机关函数，尽管父类是一个抽象类。但这只是为了初始化子对象中包含父对象的项目组，若是直接想从父类实例化一个对象，编译器报错，这是因为父类的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（）;
从汇编码可以看出，a，b虚函数在子类vtable和父类table中的地位是一样的（从它们相对于本身地点vtable的偏移量可以看出）。这就包管了非论对象实际的类型是什么，编译器总能应用同样的偏移量来调用虚函数。假如不这么做，也就是说虚函数a，b在子类Y的vtable中的地位和在父类X的vtable中的地位不一样，因为向上转型，编译器只针对父类工作，也就是对虚函数a，b的调用只会按照父类X的vtable来断定偏移量，那么在实际运行的时辰就会失足，实际的子对象底子调用不到正确的函数，多态失效。
在上方的例子中，若是将yp转为实际的类型调用c，我们会看到编译器形成的偏移量为8byte，汇编代码如下:
; 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
对象切片
若是进行向上转型的时辰不是用传地址或者引用，而是用传值，那么就会产生对象切片，即派生类对象华夏有的项目组被切除，只保存了基类的项目组。
下面是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;
}
};
void f（X x） {//用传值的情势进行向上转换
x.b（）;
}
int main（） {
Y y;
f（y）;
}
下面是main函数的汇编码:
; 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
从汇编吗中可以看出，姑且对象的大小为父类X的大小，调用的拷贝函数也是父类X的拷贝函数。
下面是父类X的拷贝函数汇编码:
？？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
从拷贝函数可以看出，姑且对象只拷贝了y的所包含的的父对象项目组（y被切片了），并且姑且对象的vptr指针也初始化为类X的vtable首地址。
下面是函数f的汇编码:
; 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
这里调用的是类X里面的成员函数，并且没有接见虚表vtable
下面是类X里面的虚成员函数b的汇编码:
？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
在c++中，当一个类含有虚函数的时辰，类就具有了多态性。机关函数的一项首要功能就是初始化vptr指针，这是包管多态性的关键步调。
机关函数初始化vptr指针
下面是c++源码:
class X {
private:
int i;
public:
X（int ii） {
i = ii;
}
virtual void set（int ii） {//虚函数
i = ii;
}
};
int main（） {
X x（1）;
}
下面是对应的main函数汇编码:
_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
从汇编码可以看到，因为类X具有虚函数，main函数在栈上为对象x预留了8byte的空间，用来存放vptr指针和成员变量i。
下面是x的机关函数的汇编码:
？？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
从代码中可以看出来，编译器确切暗中插入了代码，来用vtable的首地址初始化vptr指针，并且vptr指针位于对象首地址处。
若是类有持续关系，机关函数又如何初始化vptr指针呢？
下面是c++源码:
class X {
private:
int i;
public:
virtual void f（） {}
};
class Y : public X {//Y持续自X
private:
int j;
};
int main（） {
Y y;
}
下面是main函数中的汇编码:
_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
下面是子类机关函数汇编码:
？？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
下面是父类机关函数汇编码:
？？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
从上面子类和父类的机关函数汇编码可以看出来，子对象包含父对象，在机关子对象的时辰先机关父对象（子对象机关函数先调用父对象机关函数）。并且父对象的首地址和子对象的首地址一样（经由过程汇编码中ecx传递的值可以看出来），是以父对象和子对象的vptr指针位于同一处。所以，在机关对象的构成中，vptr指针先被初始化指向父对象的vtable首地址（在父对象机关函数中），最后又被初始化为指向子对象的vtable首地址（在子对象的机关函数中）。是以，在涉及持续的时辰，vptr指针的值由最后调用的机关函数决意。
在机关函数调用虚函数机制失效，也就是说，在机关函数中调用虚函数老是本地版本（析构函数中也是一样）
c++源码如下:
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;
}
下面首要来看父类X和子类Y中的机关函数的汇编码:
子类Y的机关函数汇编码:
？？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
父类X机关函数的汇编码:
？？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
从汇编码中可以看到，机关函数中确切不存在虚机制，都只调用本地版本的函数
析构函数
析构函数在履行的时辰，会先将vptr指针初始化为当前类的虚表vtable首地址，然则若是析构函数时编译器供给非无用的默认析构函数，则不会有vptr指针的初始化操纵:
c++源码:
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;
}
类Y析构函数汇编码:
？？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
从汇编码可以看到，编译器为y对象供给了非无用的默认析构函数，用来调用父类的析构函数，然则在y对象的析构函数里面，并没有初始化y对象vptr指针指向类Y的虚表vtable的操纵。
下面是类X的析构函数汇编码:
？？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
父类的析构函数有初始化vptr的操纵。
抽象基类
c++源码如下:
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;
}
只看父类X的机关函数和子类Y的机关函数的汇编码:
子类Y机关函数的汇编码:
？？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
父类X机关函数汇编码:
？？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
从汇编码可以看出，在机关子类的过程中，依然调用了父类的机关函数，尽管父类是一个抽象类。但这只是为了初始化子对象中包含父对象的项目组，若是直接想从父类实例化一个对象，编译器报错，这是因为父类的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（）;
从汇编码可以看出，a，b虚函数在子类vtable和父类table中的地位是一样的（从它们相对于本身地点vtable的偏移量可以看出）。这就包管了非论对象实际的类型是什么，编译器总能应用同样的偏移量来调用虚函数。假如不这么做，也就是说虚函数a，b在子类Y的vtable中的地位和在父类X的vtable中的地位不一样，因为向上转型，编译器只针对父类工作，也就是对虚函数a，b的调用只会按照父类X的vtable来断定偏移量，那么在实际运行的时辰就会失足，实际的子对象底子调用不到正确的函数，多态失效。
在上方的例子中，若是将yp转为实际的类型调用c，我们会看到编译器形成的偏移量为8byte，汇编代码如下:
; 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
对象切片
若是进行向上转型的时辰不是用传地址或者引用，而是用传值，那么就会产生对象切片，即派生类对象华夏有的项目组被切除，只保存了基类的项目组。
下面是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;
}
};
void f（X x） {//用传值的情势进行向上转换
x.b（）;
}
int main（） {
Y y;
f（y）;
}
下面是main函数的汇编码:
; 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
从汇编吗中可以看出，姑且对象的大小为父类X的大小，调用的拷贝函数也是父类X的拷贝函数。
下面是父类X的拷贝函数汇编码:
？？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
从拷贝函数可以看出，姑且对象只拷贝了y的所包含的的父对象项目组（y被切片了），并且姑且对象的vptr指针也初始化为类X的vtable首地址。
下面是函数f的汇编码:
; 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
这里调用的是类X里面的成员函数，并且没有接见虚表vtable
下面是类X里面的虚成员函数b的汇编码:
？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
