欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

從匯編看c++中的多態(tài)詳解

 更新時間：2016年06月21日 15:34:16   投稿：jingxian  
下面小編就為大家?guī)硪黄獜膮R編看c++中的多態(tài)詳解。小編覺得挺不錯的，現在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

在c++中，當一個類含有虛函數的時候，類就具有了多態(tài)性。構造函數的一項重要功能就是初始化vptr指針，這是保證多態(tài)性的關鍵步驟。

構造函數初始化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字節(jié) 成員變量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

從匯編碼中可以看到，構造函數中確實不存在虛機制，都只調用本地版本的函數

析構函數

析構函數在執(zhí)行的時候，會先將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不完全，編譯器不能安全的創(chuàng)建一個抽象類對象。而在構造子對象的構成當中，雖然在構造子對象中所包含的的父對象部分，vptr暫時指向了父類的vtable，但是，當子對象構造完成時，vptr最終指向了子類的vtable。子類的vtable是一個完整的，因此編譯器允許。

多態(tài)的晚捆綁機制只有在用地址或者引用調用虛函數的時候才有效，如果用對象本身直接調用虛函數，則不會出現晚捆綁，而是直接調用。

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;//棧上創(chuàng)建對象
 Y* yp = new Y;//堆上創(chuàng)建對象
 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;//棧上創(chuàng)建對象
 Y* yp = new Y;//堆上創(chuàng)建對象
 y.f();//用對象直接調用
 yp->f();//用指針間接調用
}

主要來看用對象直接調用函數f和用指針調用函數f的匯編碼:

用對象直接調用函數f的匯編碼:

; 25  : y.f();

  lea  ecx, DWORD PTR _y$[ebp];將棧上創(chuàng)建的對象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];將堆上創(chuàng)建的對象首地址所指向的內容給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

當子類繼承父類時，編譯器為子類重新創(chuàng)建一個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來確定偏移量，那么在實際運行的時候就會出錯，實際的子對象根本調用不到正確的函數，多態(tài)失效。

在上面的例子中，如果將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

對象切片

如果進行向上轉型的時候不是用傳地址或者引用，而是用傳值，那么就會發(fā)生對象切片，即派生類對象中原有的部分被切除，只保留了基類的部分。

下面是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++中的多態(tài)詳解就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持腳本之家。

相關文章

  • 詳解C++中對構造函數和賦值運算符的復制和移動操作

    詳解C++中對構造函數和賦值運算符的復制和移動操作

    這篇文章主要介紹了C++中對構造函數和賦值運算符的復制和移動,是C++入門學習中的基礎知識,需要的朋友可以參考下
    2016-01-01
  • C++實現水仙花數判斷實例

    C++實現水仙花數判斷實例

    大家好，本篇文章主要講的是C++實現水仙花數判斷實例，感興趣的同學趕快來看一看吧，對你有幫助的話記得收藏一下，方便下次瀏覽
    2022-01-01
  • C/C++詳解實現二層轉發(fā)

    C/C++詳解實現二層轉發(fā)

    數據鏈路層是開放系統(tǒng)互連 (OSI) 模型中的第二層，該層用于通過 LAN 等單一網絡進行通信的節(jié)點，第二層數據包不能從一個網絡傳輸到另一個網絡。而二層轉發(fā)是根據報文的目的MAC直接進行轉發(fā)，轉發(fā)過程中不用對報文的頭部做任何的修改
    2022-05-05
  • C++?this原理與可變參數及友元函數友元類分步詳解用法

    C++?this原理與可變參數及友元函數友元類分步詳解用法

    可變參數模板（variadic?templates）是C++11新增的強大的特性之一，它對模板參數進行了高度泛化，能表示0到任意個數、任意類型的參數，這篇文章主要介紹了C++?this原理與可變參數及友元函數友元類
    2022-11-11
  • C++中對象&類的深入理解

    C++中對象&類的深入理解

    這篇文章主要給大家介紹了關于C++中對象&類的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
    2021-05-05
  • 詳解C語言如何計算結構體大小(結構體的內存對齊)

    詳解C語言如何計算結構體大小(結構體的內存對齊)

    結構體的內存對齊是有關結構體內容的很重要一個知識點，主要考察方式是計算結構體的字節(jié)大小，所以本文就給大家詳細介紹一下C語言如何計算結構體大小，文中的代碼示例介紹的非常詳細,需要的朋友可以參考下
    2023-07-07
  • C語言中編寫可變參數函數

    C語言中編寫可變參數函數

    這篇文章主要介紹了C語言中編寫可變參數函數的相關資料,需要的朋友可以參考下
    2017-07-07
  • Qt實現字符串生成二維碼功能

    Qt實現字符串生成二維碼功能

    這篇文章主要介紹了如何利用Qt實現字符串生成二維碼功能，文中的實現過程講解詳細，對我們學習Qt有一定的幫助，需要的可以參考一下
    2022-01-01
  • C語言動態(tài)內存規(guī)劃詳解

    C語言動態(tài)內存規(guī)劃詳解

    這篇文章主要介紹了C語言動態(tài)內存的規(guī)劃，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
    2021-10-10
  • C程序讀取鍵盤碼的方法

    C程序讀取鍵盤碼的方法

    這篇文章主要介紹了C程序讀取鍵盤碼的方法,運行時可通過鍵盤按鍵獲取其對應的鍵盤碼,文章最后附帶了鍵盤碼與按鍵的對照表,需要的朋友可以參考下
    2014-09-09

最新評論