从汇编看c++中的多态详解
在c++中，当一个类含有虚函数的时候，类就具有了多态性。构造函数的一项重要功能就是初始化vptr指针，这是保证多态性的关键步骤。
构造函数初始化vptr指针
下面是c++源码:
classX{
private:
inti;
public:
X(intii){
i=ii;
}
virtualvoidset(intii){//虚函数
i=ii;
}
};
intmain(){
Xx(1);
}
下面是对应的main函数汇编码:
_mainPROC
;16:intmain(){
pushebp
movebp,esp
subesp,8;为对象x预留8byte空间vptr指针占4字节成员变量i占4byte
;17:Xx(1);
push1;//将1压栈，作为参数传递给构造函数
leaecx,DWORDPTR_x$[ebp];//获取x的首地址，即this指针，作为隐含参数传递给构造器
call??0X@@QAE@H@Z;为x调用构造器
;18:}
xoreax,eax
movesp,ebp
popebp
ret0
_mainENDP
从汇编码可以看到，由于类X具有虚函数，main函数在栈上为对象x预留了8byte的空间，用来存放vptr指针和成员变量i。
下面是x的构造函数的汇编码:
??0X@@QAE@H@ZPROC;X::X,COMDAT
;_this$=ecx
;5:X(intii){
pushebp
movebp,esp
pushecx;压栈ecx的目的是为了给this指针(x对象首地址)预留4byte的空间
movDWORDPTR_this$[ebp],ecx;将this指针存储到刚才预留的空间里ecx里面存放了x的首地址
moveax,DWORDPTR_this$[ebp];将x的首地址给寄存器eax
movDWORDPTR[eax],OFFSET??_7X@@6B@;将??_7X@@6B@的偏移地址(即vtable的首地址)放到x对象的首地址指向的内存储这里就是初始化vptr指针
;6:i=ii;
movecx,DWORDPTR_this$[ebp];将x首地址给ecx
movedx,DWORDPTR_ii$[ebp];将参数ii的值给寄存器edx
movDWORDPTR[ecx+4],edx;将寄存器eax的值写入偏移x首地址4byte处的内存，即给x的成员变量i赋值
;7:}
moveax,DWORDPTR_this$[ebp];将x对象首地址给寄存器eax，作为返回值。构造函数总是返回对象首地址
movesp,ebp
popebp
ret4
??0X@@QAE@H@ZENDP
从代码中可以看出来，编译器确实暗中插入了代码，来用vtable的首地址初始化vptr指针，并且vptr指针位于对象首地址处。
如果类有继承关系，构造函数又如何初始化vptr指针呢？
下面是c++源码:
classX{
private:
inti;
public:
virtualvoidf(){}
};
classY:publicX{//Y继承自X
private:
intj;
};
intmain(){
Yy;
}
下面是main函数中的汇编码:
_mainPROC
;16:intmain(){
pushebp
movebp,esp
subesp,12;为对象y预留12byte的空间vptr指针4byte父类成员变量4byte子类成员变量4byte
;17:Yy;
leaecx,DWORDPTR_y$[ebp];获取对象y的首地址(即this指针),作为隐含参数传递给构造函数
call??0Y@@QAE@XZ;调用y的构造函数虽然y没有显示定义构造函数，但由于其含有虚成员函数，编译器提供默认构造函数
;18:}
xoreax,eax
movesp,ebp
popebp
ret0
_mainENDP
下面是子类构造函数汇编码:
??0Y@@QAE@XZPROC;Y::Y,COMDAT ;_this$=ecx pushebp movebp,esp pushecx;//压栈ecx的目的是存放this指针 movDWORDPTR_this$[ebp],ecx;将this指针(即对象首地址)放到刚才预留空间ecx里面存放对象首地址 movecx,DWORDPTR_this$[ebp];将对象首地址给ecx作为隐含参数传递给父类构造函数 call??0X@@QAE@XZ;调用父类构造函数 moveax,DWORDPTR_this$[ebp];将y的首地址给寄存器eax movDWORDPTR[eax],OFFSET??_7Y@@6B@;将y的vtable(??_7Y@@6B@)首地址赋给y对象首地址所指内存即初始化子类vptr指针 moveax,DWORDPTR_this$[ebp];将y首地址给eax，作为返回值。构造函数总是返回对象首地址 movesp,ebp popebp ret0 ??0Y@@QAE@XZENDP
下面是父类构造函数汇编码:
??0X@@QAE@XZPROC;X::X,COMDAT ;_this$=ecx pushebp movebp,esp pushecx;压栈的目的是为了存放this指针(父对象对象首地址)预留空间 movDWORDPTR_this$[ebp],ecx;将父对象对象首地址(ecx中保存)放入刚才预留空间 moveax,DWORDPTR_this$[ebp];将父对象首地址给寄存器eax movDWORDPTR[eax],OFFSET??_7X@@6B@;将vtable(??_7X@@6B@和子类不同)首地址赋给父对象首地址处的内存即初始化父对象的vptr指针 moveax,DWORDPTR_this$[ebp];将父对象的首地址传给eax，作为返回值。构造函数总是返回对象首地址 movesp,ebp popebp ret0 ??0X@@QAE@XZENDP
从上面子类和父类的构造函数汇编码可以看出来，子对象包含父对象，在构造子对象的时候先构造父对象(子对象构造函数先调用父对象构造函数)。而且父对象的首地址和子对象的首地址一样(通过汇编码中ecx传递的值可以看出来)，因此父对象和子对象的vptr指针位于同一处。所以，在构造对象的构成中，vptr指针先被初始化指向父对象的vtable首地址(在父对象构造函数中)，最后又被初始化为指向子对象的vtable首地址(在子对象的构造函数中)。因此，在涉及继承的时候，vptr指针的值由最后调用的构造函数决定。
在构造函数调用虚函数机制失效，也就是说，在构造函数中调用虚函数总是本地版本(析构函数中也是一样)
c++源码如下:
classX{
private:
inti;
public:
virtualvoidf(intii){
i=ii;
}
X(){
f(1);
}
};
classY:publicX{//Y继承自X
private:
intj;
public:
virtualvoidf(intii){
j=ii;
}
Y(){
f(2);
}
};
intmain(){
Yy;
}
下面主要来看父类X和子类Y中的构造函数的汇编码:
子类Y的构造函数汇编码:
??0Y@@QAE@XZPROC;Y::Y,COMDAT
;_this$=ecx
;20:Y(){
pushebp
movebp,esp
pushecx;压栈的目的是为存放this指针(在ecx寄存器里面存放了子对象首地址)预留空间
movDWORDPTR_this$[ebp],ecx;将子对象首地址存入刚才预留空间
movecx,DWORDPTR_this$[ebp];将子类首地址作为隐含参数传给父对象构造器(子对象首地址和父对象首地址一样)
call??0X@@QAE@XZ;调用父类构造器
moveax,DWORDPTR_this$[ebp];将子对象首地址传给寄存器eax
movDWORDPTR[eax],OFFSET??_7Y@@6B@;将子对象的vtable首地址存到子对象首地址所指向的内存，即初始化子对象的vptr指针
;21:f(2);
push2;将2压栈，作为参数调用函数f，这里，子对象调用的是自己的函数f
movecx,DWORDPTR_this$[ebp];将子对象首地址传给ecx，作为隐含参数传递给成员函数f
call?f@Y@@UAEXH@Z;调用子对象中的f函数
;22:}
moveax,DWORDPTR_this$[ebp];将子对象首地址给寄存器eax，作为返回值。构造器总是返回对象首地址
movesp,ebp
popebp
ret0
??0Y@@QAE@XZENDP;Y::Y
父类X构造函数的汇编码:
??0X@@QAE@XZPROC;X::X,COMDAT
;_this$=ecx
;8:X(){
pushebp
movebp,esp
pushecx;压栈的目的是存放父对象首地址预留空间父对象首地址和子对象首地址一样
movDWORDPTR_this$[ebp],ecx;ecx里面存放父对象首地址，传给刚才预留的空间
moveax,DWORDPTR_this$[ebp];将父对象首地址传给eax
movDWORDPTR[eax],OFFSET??_7X@@6B@;将父对象的vtable首地址写入父对象首地址所指向的内存即初始化父对象的vptr指针
;9:f(1);
push1;将1压栈，作为参数调用函数f这里调用时父对象的版本
movecx,DWORDPTR_this$[ebp];将父对象首地址作为隐含参数传给f
call?f@X@@UAEXH@Z;调用函数f
;10:}
moveax,DWORDPTR_this$[ebp];将父对象首地址传给eax作为返回值。构造函数总是返回对象首地址
movesp,ebp
popebp
ret0
??0X@@QAE@XZENDP
从汇编码中可以看到，构造函数中确实不存在虚机制，都只调用本地版本的函数
析构函数
析构函数在执行的时候，会先将vptr指针初始化为当前类的虚表vtable首地址，但是如果析构函数时编译器提供非无用的默认析构函数，则不会有vptr指针的初始化操作:
c++源码:
classX{
private:
inti;
public:
virtualvoidset(intii){
i=ii;
}
~X(){}
};
classY:publicX{
private:
inti;
};
intmain(){
Yy;
}
类Y析构函数汇编码:
??1Y@@QAE@XZPROC;Y::~Y,COMDAT ;_this$=ecx pushebp movebp,esp pushecx;为传进来的y对象首地址预留空间 movDWORDPTR_this$[ebp],ecx;ecx中保存y对象首地址，存到刚才空间中 movecx,DWORDPTR_this$[ebp];将y对象首地址(y对象包含父对象，他们的首地址一样)传给ecx，作为隐含参数传地址类X的析构函数 call??1X@@QAE@XZ;调用类X的析构函数 movesp,ebp popebp ret0 ??1Y@@QAE@XZENDP
从汇编码可以看到，编译器为y对象提供了非无用的默认析构函数，用来调用父类的析构函数，但是在y对象的析构函数里面，并没有初始化y对象vptr指针指向类Y的虚表vtable的操作。
下面是类X的析构函数汇编码:
??1X@@QAE@XZPROC;X::~X,COMDAT
;_this$=ecx
;9:~X(){}
pushebp
movebp,esp
pushecx;为传进来的父对象的首地址预留空间
movDWORDPTR_this$[ebp],ecx;为将传进来的父对象首地址存放到刚才空间
moveax,DWORDPTR_this$[ebp];父对象首地址给eax
movDWORDPTR[eax],OFFSET??_7X@@6B@;将父类vtable首地址给父对象首地址处的内存即初始化父对象中的vptr指针
movesp,ebp
popebp
ret0
??1X@@QAE@XZENDP
父类的析构函数有初始化vptr的操作，此时的vptr所指向的虚表已经是类X所对应的虚表，而不是子类Y对应的虚表。
抽象基类
c++源码如下:
classX{
private:
inti;
public:
virtualvoidf()=0;//纯虚函数
X(){
i=1;
}
};
classY:publicX{//Y继承自X
private:
intj;
public:
virtualvoidf(){
j=2;
}
};
intmain(){
Yy;
}
只看父类X的构造函数和子类Y的构造函数的汇编码:
子类Y构造函数的汇编码:
??0Y@@QAE@XZPROC;Y::Y,COMDAT ;_this$=ecx pushebp movebp,esp pushecx;为保存子对象首地址预留空间 movDWORDPTR_this$[ebp],ecx;将ecx(里面存放子对象首地址)的值放到刚才的空间 movecx,DWORDPTR_this$[ebp];将子对象首地址传给ecx，作为隐含参数(this指针)调用父对象的构造函数 call??0X@@QAE@XZ;调用父对象的构造函数 moveax,DWORDPTR_this$[ebp];将子对象首地址给eaxt movDWORDPTR[eax],OFFSET??_7Y@@6B@;将子对象的vtable首地址存到子对象首地址所指向的内存，即初始化子对象的vptr moveax,DWORDPTR_this$[ebp];将子对象的首地址给eax，作为返回值。构造函数总是返回对象首地址 movesp,ebp popebp ret0 ??0Y@@QAE@XZENDP
父类X构造函数汇编码:
??0X@@QAE@XZPROC;X::X,COMDAT
;_this$=ecx
;6:X(){
pushebp
movebp,esp
pushecx;压栈的目的就是为存储父对象首地址(即this指针)预留空间
movDWORDPTR_this$[ebp],ecx;将父对象首地址存到刚才的空间
moveax,DWORDPTR_this$[ebp];将父对象的首地址传给eax
movDWORDPTR[eax],OFFSET??_7X@@6B@;将父对象的vtable(由于父类为抽象类，其vtable不完全，即里面没有存放纯虚函数的地址，只为其保留了一个位置)首地址存到父对象首地址所指的内存即初始化父对象的vptr指针
;7:i=1;
movecx,DWORDPTR_this$[ebp];将父对象的首地址给ecx
movDWORDPTR[ecx+4],1;将1存到偏移父对象首地址4byte处，即给父对象的成员变量i赋值
;8:}
moveax,DWORDPTR_this$[ebp];父对象的首地址给eax作为返回值。构造函数总是返回对象首地址
movesp,ebp
popebp
ret0
??0X@@QAE@XZENDP
从汇编码可以看出，在构造子类的过程中，依然调用了父类的构造函数，尽管父类是一个抽象类。但这只是为了初始化子对象中包含父对象的部分，如果直接想从父类实例化一个对象，编译器报错，这是因为父类的vtable不完全，编译器不能安全的创建一个抽象类对象。而在构造子对象的构成当中，虽然在构造子对象中所包含的的父对象部分，vptr暂时指向了父类的vtable，但是，当子对象构造完成时，vptr最终指向了子类的vtable。子类的vtable是一个完整的，因此编译器允许。
多态的晚捆绑机制只有在用地址或者引用调用虚函数的时候才有效，如果用对象本身直接调用虚函数，则不会出现晚捆绑，而是直接调用。
c++源码:
classX{
private:
inti;
public:
virtualvoidf(){
i=1;
}
};
classY:publicX{//Y继承自X
private:
intj;
public:
virtualvoidf(){
j=2;
}
};
intmain(){
Yy;//栈上创建对象
Y*yp=newY;//堆上创建对象
y.f();//用对象直接调用
yp->f();//用指针间接调用
}
classX{
private:
inti;
public:
virtualvoidf(){
i=1;
}
};
classY:publicX{//Y继承自X
private:
intj;
public:
virtualvoidf(){
j=2;
}
};
intmain(){
Yy;//栈上创建对象
Y*yp=newY;//堆上创建对象
y.f();//用对象直接调用
yp->f();//用指针间接调用
}
主要来看用对象直接调用函数f和用指针调用函数f的汇编码:
用对象直接调用函数f的汇编码:
;25:y.f(); leaecx,DWORDPTR_y$[ebp];将栈上创建的对象y的首地址给ecx，作为隐含参数传递给f call?f@Y@@UAEXXZ;用绝对地址调用f
用指针间接调用函数f的汇编码:
;26:yp->f(); movecx,DWORDPTR_yp$[ebp];将yp指针指向的堆对象的首地址给ecx movedx,DWORDPTR[ecx];将堆上创建的对象首地址所指向的内容给edx即将vptr指针指向的vtable首地址给edx movecx,DWORDPTR_yp$[ebp];将yp指针指向的堆对象的首地址给ecx作为隐含参数传递给要调用的函数f moveax,DWORDPTR[edx];edx存的是vtable首地址，这里取vtable首地址的内容给eax即函数f的地址给eax calleax;调用eax
从汇编码中可以看出，用对象直接调用的时候根本没有访问虚表vtable，只有用指针调用的时候才会访问vtable，形成晚捆绑。因为用对象直接调用的时候，编译器已经知道了对象的确切类型，为了提高效率，当调用这些虚函数的时候，使用了造捆绑。
继承和vtable
当子类继承父类时，编译器为子类重新创建一个vtable，并且父类中的虚函数在父类vatelbe中的位置准确的映射到子类vtable中的同样位置，对于子类中重新定义的虚函数，将在子类vtable的新位置插入其地址。
下面是c++源码:
classX{
private:
inti;
public:
virtualvoida(){
i=1;
}
virtualvoidb(){
i=2;
}
};
classY:publicX{
private:
inti;
public:
virtualvoidc(){//新定义的虚函数
i=3;
}
voidb(){//重写父类中的虚函数
i=4;
}
};
intmain(){
X*xp=newX;
X*yp=newY;
xp->a();
xp->b();
yp->a();
yp->b();
//yp->c();编译器报错
}
可以看到，用yp指针调用子类中的虚函数c，编译器报错。这是因为尽管yp指针所指向的时机类型是子类Y，但是由于向上转型为基类X类型，因此，编译器在编译的时候只针对基类，而基类只有虚函数a，b，所以不允许调用子类中的虚函数c。
下面只给出调用虚函数时的汇编代码:
;28:xp->a(); movedx,DWORDPTR_xp$[ebp];将xp所指向的堆对象首地址给edx moveax,DWORDPTR[edx];将堆对象首地址里面的内容给eax，即将vptr指向的vtable首地址给eax movecx,DWORDPTR_xp$[ebp];将xp所指向的堆对象首地址给ecx，作为隐含参数传递给即将调用的虚成员函数 movedx,DWORDPTR[eax];将vtable首地址里面的内容给edx，即将虚函数a的地址给edx(这里，虚函数a的地址位于父类X的vtable首地址处) calledx;调用虚成员函数a ;29:xp->b(); moveax,DWORDPTR_xp$[ebp];将xp所指堆对象的首地址给eax movedx,DWORDPTR[eax];将堆对象首地址的内容给edx，即将vptr指向的vtable首地址给edx movecx,DWORDPTR_xp$[ebp];将xp所指堆对象的首地址给ecx moveax,DWORDPTR[edx+4];将偏移vtable首地址4byte处内存内容给eax，即将虚函数b的地址给eax(这里，虚函数b的地址位于偏移父类X的vtable首地址4byte处) calleax;调用虚成员函数b ;30:yp->a(); movecx,DWORDPTR_yp$[ebp];将yp所指向的堆对象的首地址给ecx movedx,DWORDPTR[ecx];将堆对象首地址的内容给edx，即将子类vptr指向的vtable首地址给edx movecx,DWORDPTR_yp$[ebp];将yp所指向的堆对象首地址给ecx，作为隐含参数传递给虚成员函数a moveax,DWORDPTR[edx];将子类vtable首地址处的内容给eax，即将虚函数a的地址给eax(这里，虚函数a的地址同样位于子类Y的vtable首地址处) calleax;调用虚成员函数a ;31:yp->b(); movecx,DWORDPTR_yp$[ebp];将yp所指向的堆对象的首地址给ecx movedx,DWORDPTR[ecx];将堆对象首地址的内容给edx，即将子类vptr指向的vtable首地址给edx movecx,DWORDPTR_yp$[ebp];将yp所指向的堆对象首地址给ecx，作为隐含参数传递给虚成员函数b moveax,DWORDPTR[edx+4];将偏移子类vtable首地址4byte处内存的内容给eax，即将虚函数b的地址给eax(这里，虚函数b的地址同样位于偏移子类Y的vtable首地址4byte处) calleax;调用虚成员函数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(); movecx,DWORDPTR_yp$[ebp];将yp所指向的堆对象的首地址给ecx movedx,DWORDPTR[ecx];将堆对象首地址的内容给edx，即将子类vptr指向的vtable首地址给edx movecx,DWORDPTR_yp$[ebp];将yp所指向的堆对象首地址给ecx，作为隐含参数传递给虚成员函数c moveax,DWORDPTR[edx+8];将偏移子类vtable首地址8byte处内存的内容给eax，即将虚函数c的地址给eax(这里，虚函数b的地址同样位于偏移子类Y的vtable首地址8byte处) calleax;调用虚成员函数c
对象切片
如果进行向上转型的时候不是用传地址或者引用，而是用传值，那么就会发生对象切片，即派生类对象中原有的部分被切除，只保留了基类的部分。
下面是c++源码:
classX{
private:
inti;
public:
virtualvoida(){
i=1;
}
virtualvoidb(){
i=2;
}
};
classY:publicX{
private:
inti;
public:
virtualvoidc(){//新定义的虚函数
i=3;
}
voidb(){//重写父类中的虚函数
i=4;
}
};
voidf(Xx){//用传值的形式进行向上转换
x.b();
}
intmain(){
Yy;
f(y);
}
下面是main函数的汇编码:
;28:intmain(){
pushebp
movebp,esp
subesp,16;为对象y预留16byte的空间
;29:Yy;
leaecx,DWORDPTR_y$[ebp];将y的首地址给ecx，转为隐含参数传递给y的构造函数
call??0Y@@QAE@XZ;调用y的构造函数
;30:f(y);
subesp,8;//由于对象传值，要进行拷贝，产生临时对象，这里为临时对象预留8byte的空间(类X的大小)
movecx,esp;//将临时对象的首地址给ecx，作为隐含参数传递给拷贝函数
leaeax,DWORDPTR_y$[ebp];将对象y的首地址给eax，作为参数给拷贝函数
pusheax;压栈，传递参数
call??0X@@QAE@ABV0@@Z;调用类X的拷贝函数
call?f@@YAXVX@@@Z;调用函数f
addesp,8;释放刚才的临时对象占用的8byte空间
;31:}
xoreax,eax
movesp,ebp
popebp
ret0
从汇编吗中可以看出，临时对象的大小为父类X的大小，调用的拷贝函数也是父类X的拷贝函数。
下面是父类X的拷贝函数汇编码:
??0X@@QAE@ABV0@@ZPROC;X::X,COMDAT ;_this$=ecx pushebp movebp,esp pushecx;压栈，为存对象首地址预留4byte空间 movDWORDPTR_this$[ebp],ecx;ecx中保存临时对象首地址，放到刚才预留的空间 moveax,DWORDPTR_this$[ebp];将临时对象首地址给ecx movDWORDPTR[eax],OFFSET??_7X@@6B@;将类X的vtable首地址存到临时对象首地址所指向的内存即初始化临时对象的vptr指针 movecx,DWORDPTR_this$[ebp];将临时对象的首地址给ecx movedx,DWORDPTR___that$[ebp];将y的首地址给edx moveax,DWORDPTR[edx+4];将偏移y首地址4byte处内存内容给edx，即将y包含的父对象中的成员变量i的值给edx movDWORDPTR[ecx+4],eax;将eax的值给偏移临时对象首地址4byte处内存，即将eax的值给临时对象的成员变量i moveax,DWORDPTR_this$[ebp];将临时对象的首地址给eax，作为返回值。构造函数总是返回对象首地址 movesp,ebp popebp ret4
从拷贝函数可以看出，临时对象只拷贝了y的所包含的的父对象部分(y被切片了),并且临时对象的vptr指针也初始化为类X的vtable首地址。
下面是函数f的汇编码:
;24:voidf(Xx){
pushebp
movebp,esp
;25:x.b();
leaecx,DWORDPTR_x$[ebp];将参数x的首地址给ecx，作为隐含参数传递给成员函数b
call?b@X@@UAEXXZ;调用x中的成员函数b这里是用对象直接调用，因此没有访问vtable
这里调用的是类X里面的成员函数，并且没有访问虚表vtable
下面是类X里面的虚成员函数b的汇编码:
?b@X@@UAEXXZPROC;X::b,COMDAT
;_this$=ecx
;8:virtualvoidb(){
pushebp
movebp,esp
pushecx;为保存对象首地址预留4byte空间
movDWORDPTR_this$[ebp],ecx;ecx中保存有对象x的首地址，放到刚才预留的空间
;9:i=2;
moveax,DWORDPTR_this$[ebp];将x首地址给eax
movDWORDPTR[eax+4],2;将2写给偏移x首地址4byte处，即将2赋给x的成员变量i
;10:}
movesp,ebp
popebp
ret0
?b@X@@UAEXXZENDP
以上这篇从汇编看c++中的多态详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。