程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> 從匯編看c++中的多態詳解

從匯編看c++中的多態詳解

編輯:關於C++

從匯編看c++中的多態詳解。本站提示廣大學習愛好者:(從匯編看c++中的多態詳解)文章只能為提供參考,不一定能成為您想要的結果。以下是從匯編看c++中的多態詳解正文


在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的操作,此時的vptr所指向的虛表曾經是類X所對應的虛表,而不是子類Y對應的虛表。

籠統基類

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++中的多態詳解就是小編分享給年夜家的全體內容了,願望能給年夜家一個參考,也願望年夜家多多支撐。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved