覆蓋：如果派生類中的方法，和基類繼承來的某個方法，返回值、函數名、參數列表都相同，而且基類的方法是virtual虛函數，那么派生類的這個方法，自動處理成虛函數，它們之間成為覆蓋關系；也就是說派生類會在自己虛函數表中將從基類繼承來的虛函數進行替換，替換成派生類自己的。
靜態綁定：編譯時期的多態，通過函數的重載以及模板來實現，也就是說調用函數的地址在編譯時期我們就可以確定，在匯編代碼層次，呈現的就是 call 函數名；
動態綁定：運行時期的多態，通過派生類重寫基類的虛函數來實現。在匯編代碼層次，呈現的就是 call 寄存器，寄存器的值只有運行起來我們才可以確定。
不存在虛函數
#include <iostream>
#include <typeinfo>
class Base
{
public:
Base(int data = 10): ma(data) {}
~Base() {};
void show() {
std::cout << "Base::show()" << std::endl;
}
void show(int data) {
std::cout << "Base::show()" << data << std::endl;
}
protected:
int ma;
};
class Derive :public Base
{
public:
Derive(int data) :Base(data), mb(data) {}
~Derive() {}
void show() {
std::cout << "Derive::show()" << std::endl;
}
private:
int mb;
};
int main() {
Derive d(50);
Base *pb = &d;
pb->show();//靜態（編譯時期）綁定(函數調用) Base::show (06F12E4h)
pb->show(10);//Base::show (06F12BCh)
std::cout << "Base size:" << sizeof(Base) << std::endl;//4
std::cout << "Derive size:" << sizeof(Derive) << std::endl;//8
std::cout << typeid(pb).name() << std::endl;//class Base *
std::cout << typeid(*pb).name() << std::endl;//class Base
return 0;
}
打斷點，F5進入調試，點擊反匯編
可以看到調用的都是基類的show(),在編譯階段已經生成指令調用Base下的show；
可以看到結果：
因為pb是Base類型的指針，所以調用的都是Base類的成員方法；
基類Base只有一個數據成員ma，所以大小只有4字節；
派生類Derive繼承了ma，其次還有自己的mb，所以有8字節；
pb的類型是一個class Base *；
*pb的類型是一個class Base。
為了更好地理解上述過程，我們簡單畫圖如下：
為什么Base *類型的指針，Derive類型的對象，調用方法的時候是Base而不是Derive呢？
原因如上圖：
Derive類繼承了Base類，導致了派生類的大小要比基類大，而pb的類型是基類的指針，所以通過pb調用方法時只能訪問到Derive中從Base繼承而來的方法，訪問不到自己重寫的方法（指針的類型限制了指針解引用的能力）
基類定義虛函數
#include <iostream>
#include <typeinfo>
class Base
{
public:
Base(int data = 10): ma(data) {}
~Base() {};
//虛函數
virtual void show() {
std::cout << "Base::show()" << std::endl;
}
void show(int data) {
std::cout << "Base::show()" << data << std::endl;
}
protected:
int ma;
};
class Derive :public Base
{
public:
Derive(int data) :Base(data), mb(data) {}
~Derive() {}
void show() {
std::cout << "Derive::show()" << std::endl;
}
private:
int mb;
};
int main() {
Derive d(50);
Base *pb = &d;
/*
pb->show();
pb 指針是base類型，如果發現Base中的show是虛函數，就進行動態綁定
mov ecx,dword ptr [pb]
00292B01 8B 45 D4 mov eax,dword ptr [pb] //將pb指向的內存前4個字節放入ecx寄存器，pb指向derive對象，前四個字節即vfptr，將虛函數表地址加載到eax
00292B04 8B 10 mov edx,dword ptr [eax] //將eax 的前四個字節 即Derive::show 加載到edx中
00292B06 8B F4 mov esi,esp
00292B08 8B 4D D4 mov ecx,dword ptr [pb]
00292B0B 8B 02 mov eax,dword ptr [edx]
00292B0D FF D0 call eax //虛函數的地址
00292B0F 3B F4 cmp esi,esp
00292B11 E8 9C E7 FF FF call __RTC_CheckEsp (02912B2h)
我們可以看到這一次，匯編碼call的就不是確切的函數地址了，而是寄存器eax；
那么就很好理解了：
eax寄存器里存放的是什么內容，編譯階段根本無從知曉，只能在運行的時候確定；
故，動態綁定。
pb->show(10); 如果發現show是普通函數，就進行靜態綁定 call Base::show
*/
pb->show();//
pb->show(10);//
std::cout << "Base size:" << sizeof(Base) << std::endl;//8
std::cout << "Derive size:" << sizeof(Derive) << std::endl;//12
std::cout << typeid(pb).name() << std::endl;//class Base *
/*
pb的類型：Base類型，查看Base中有沒有虛函數
（1）Base中沒有虛函數*pb識別的就是編譯時期的類型 *pb 就是Base類型
(2) Base中有虛函數，*pb識別的就是運行時期的類型 RTTI類型:Derive
*/
std::cout << typeid(*pb).name() << std::endl;//class Derive
return 0;
}
在我們添加了virtual關鍵字后，對應的函數就變成了虛函數；
那么，一個類添加了虛函數，對這個類有什么影響呢？
- 首先，如果類里面定義了虛函數，那么編譯階段，編譯器給這個類類型產生一個唯一的vftable虛函數表，虛函數表中主要存儲的內容是：RTTI(Run-time Type Information)指針和虛函數的地址，當程序運行時，每一張虛函數表都會加載到內存的.rodata區；
- 一個類里面定義了虛函數，那么這個類定義的對象，在運行時，內存中會多存儲一個vfptr虛函數指針，指向了對應類型的虛函數表vftable；
- 一個類型定義的n個對象，他們的vfptr指向的都是同一張虛函數表；
- 一個類里面虛函數的個數，不影響對象內存的大小(vfptr)，影響的是虛函數表的大小。
- 如果派生類中的方法和從基類繼承來的某個方法中返回值、函數名以及參數列表都相同，且基類的方法是virtual，那么派生類的這個方法，自動處理成虛函數
圖示如下：（以Base為例）
虛函數表
1、RTTI，存放的是類型信息，也就是（Base或者Derive）
2、偏移地址：虛函數指針相對于對象內存空間的偏移，一般vfptr都在0偏移位置
3、下面的函數時虛函數入口地址
在Derive類中，由于重寫了show(),因此在Derive的虛函數表中，是使用子類的show()方法代替了Base類的show()
VS的工具來查看虛函數表的有關信息
1 找到
2 在打開的窗口中切換到當前工程所在目錄：
C:\Program Files (x86)\Microsoft Visual Studio\2017\Community>cd C:\Users\Admin\source\repos\C++test\
3 輸入命令：cl XXX.cpp /d1reportSingleClassLayoutXX(第一個XXX表示源文件的名字，第二個代表你想查看的類類型，我這里就是Derive)
以看到class Derived的對象的內存布局，在派生類對象的開始包含了基類Base的對象，其中有一個虛表指針，指向的就是下面的Derived::$vftable@ （virtual function table），表中包含了Derived類中所有的虛函數
多重繼承、多繼承 的虛函數表 1 內存分布
假設有一個基類ClassA，一個繼承了該基類的派生類ClassB，并且基類中有虛函數，派生類實現了基類的虛函數。
我們在代碼中運用多態這個特性時，通常以兩種方式起手：
(1) ClassA *a = new ClassB();
(2) ClassB b; ClassA *a = &b;
以上兩種方式都是用基類指針去指向一個派生類實例，區別在于第1個用了new關鍵字而分配在堆上，第2個分配在棧上
請看上圖，不同兩種方式起手僅僅影響了派生類對象實例存在的位置。
以左圖為例，ClassA *a是一個棧上的指針。
該指針指向一個在堆上實例化的子類對象。基類如果存在虛函數，那么在子類對象中，除了成員函數與成員變量外，編譯器會自動生成一個指向**該類的虛函數表(這里是類ClassB)**的指針，叫作虛函數表指針。通過虛函數表指針，父類指針即可調用該虛函數表中所有的虛函數。
2 類的虛函數表與類實例的虛函數指針
首先不考慮繼承的情況。如果一個類中有虛函數，那么該類就有一個虛函數表。
這個虛函數表是屬于類的，所有該類的實例化對象中都會有一個虛函數表指針去指向該類的虛函數表。
從第一部分的圖中我們也能看到，一個類的實例要么在堆上，要么在棧上。也就是說一個類可以有很多很多個實例。但是！一個類只能有一個虛函數表。在編譯時，一個類的虛函數表就確定了，這也是為什么它放在了只讀數據段中。
3 多態代碼及多重繼承情況
在第二部分中，我們討論了在沒有繼承的情況下，虛函數表的邏輯結構。
那么在有繼承情況下，只要基類有虛函數，子類不論實現或沒實現，都有虛函數表。
#include <iostream>
using namespace std;
class ClassA
{
public:
ClassA() { cout << "ClassA::ClassA()" << endl; }
virtual ~ClassA() { cout << "ClassA::~ClassA()" << endl; }
void func1() { cout << "ClassA::func1()" << endl; }
void func2() { cout << "ClassA::func2()" << endl; }
virtual void vfunc1() { cout << "ClassA::vfunc1()" << endl; }
virtual void vfunc2() { cout << "ClassA::vfunc2()" << endl; }
private:
int aData;
};
class ClassB : public ClassA
{
public:
ClassB() { cout << "ClassB::ClassB()" << endl; }
virtual ~ClassB() { cout << "ClassB::~ClassB()" << endl; }
void func1() { cout << "ClassB::func1()" << endl; }
virtual void vfunc1() { cout << "ClassB::vfunc1()" << endl; }
private:
int bData;
};
class ClassC : public ClassB
{
public:
ClassC() { cout << "ClassC::ClassC()" << endl; }
virtual ~ClassC() { cout << "ClassC::~ClassC()" << endl; }
void func2() { cout << "ClassC::func2()" << endl; }
virtual void vfunc2() { cout << "ClassC::vfunc2()" << endl; }
private:
int cData;
};
int main()
{
ClassC c;
return 0;
}
請看上面代碼
(1) ClassA是基類, 有普通函數: func1() func2() 。虛函數: vfunc1() vfunc2() ~ClassA()
(2) ClassB繼承ClassA, 有普通函數: func1()。虛函數: vfunc1() ~ClassB()
(3) ClassC繼承ClassB, 有普通函數: func2()。虛函數: vfunc2() ~ClassB()
基類的虛函數表和子類的虛函數表不是同一個表。下圖是基類實例與多態情形下，數據邏輯結構。注意，虛函數表是在編譯時確定的，屬于類而不屬于某個具體的實例。虛函數在代碼段，僅有一份
ClassB繼承與ClassA，其虛函數表是在ClassA虛函數表的基礎上有所改動的，變化的僅僅是在子類中重寫的虛函數。如果子類沒有重寫任何父類虛函數，那么子類的虛函數表和父類的虛函數表在內容上是一致的
ClassA *a = new ClassB(); a->func1(); // "ClassA::func1()" 隱藏了ClassB的func1() a->func2(); // "ClassA::func2()" a->vfunc1(); // "ClassB::vfunc1()" 重寫了ClassA的vfunc1() a->vfunc2(); // "ClassA::vfunc2()"
這個結果不難想象，看上圖，ClassA類型的指針a能操作的范圍只能是黑框中的范圍，之所以實現了多態完全是因為子類的虛函數表指針與虛函數表的內容與基類不同
這個結果已經說明了C++的隱藏、重寫(覆蓋)特性。
同理，也就不難推導出ClassC的邏輯結構圖了
類的繼承情況是: ClassC繼承ClassB，ClassB繼承ClassA
這是一個多次單繼承的情況。(多重繼承)
4、多繼承下的虛函數表 (同時繼承多個基類)
多繼承是指一個類同時繼承了多個基類，假設這些基類都有虛函數，也就是說每個基類都有虛函數表，那么該子類的邏輯結果和虛函數表是什么樣子呢？
#include <iostream>
using namespace std;
class ClassA1
{
public:
ClassA1() { cout << "ClassA1::ClassA1()" << endl; }
virtual ~ClassA1() { cout << "ClassA1::~ClassA1()" << endl; }
void func1() { cout << "ClassA1::func1()" << endl; }
virtual void vfunc1() { cout << "ClassA1::vfunc1()" << endl; }
virtual void vfunc2() { cout << "ClassA1::vfunc2()" << endl; }
private:
int a1Data;
};
class ClassA2
{
public:
ClassA2() { cout << "ClassA2::ClassA2()" << endl; }
virtual ~ClassA2() { cout << "ClassA2::~ClassA2()" << endl; }
void func1() { cout << "ClassA2::func1()" << endl; }
virtual void vfunc1() { cout << "ClassA2::vfunc1()" << endl; }
virtual void vfunc2() { cout << "ClassA2::vfunc2()" << endl; }
virtual void vfunc4() { cout << "ClassA2::vfunc4()" << endl; }
private:
int a2Data;
};
class ClassC : public ClassA1, public ClassA2
{
public:
ClassC() { cout << "ClassC::ClassC()" << endl; }
virtual ~ClassC() { cout << "ClassC::~ClassC()" << endl; }
void func1() { cout << "ClassC::func1()" << endl; }
virtual void vfunc1() { cout << "ClassC::vfunc1()" << endl; }
virtual void vfunc2() { cout << "ClassC::vfunc2()" << endl; }
virtual void vfunc3() { cout << "ClassC::vfunc3()" << endl; }
};
int main()
{
ClassC c;
return 0;
}
ClassA1是第一個基類，擁有普通函數func1()，虛函數vfunc1() vfunc2()。
ClassA2是第二個基類，擁有普通函數func1()，虛函數vfunc1() vfunc2()，vfunc4()。
ClassC依次繼承ClassA1、ClassA2。普通函數func1(),虛函數vfunc1() vfunc2() vfunc3()。
在多繼承情況下，有多少個基類就有多少個虛函數表指針，前提是基類要有虛函數才算上這個基類。
如圖，虛函數表指針01指向的虛函數表是以ClassA1的虛函數表為基礎的，子類的ClassC::vfunc1(),和vfunc2()的函數指針覆蓋了虛函數表01中的虛函數指針01的位置、02位置。當子類有多出來的虛函數時，添加在第一個虛函數表中。注意：
1.子類虛函數會覆蓋每一個父類的每一個同名虛函數。
2.父類中沒有的虛函數而子類有，填入第一個虛函數表中，且用父類指針是不能調用。
3.父類中有的虛函數而子類沒有，則不覆蓋。僅子類和該父類指針能調用
虛基類和多重繼承
什么是多重繼承
多重繼承，很好理解，一個派生類如果只繼承一個基類，稱作單繼承；
一個派生類如果繼承了多個基類，稱作多繼承。
如圖所示：
多重繼承的優點
這個很好理解：
多重繼承可以做更多的代碼復用！
派生類通過多重繼承，可以得到多個基類的數據和方法，更大程度的實現了代碼復用。
關于菱形繼承的問題
凡事有利也有弊，對于多繼承而言，也有自己的缺點。
我們先通過了解菱形繼承來探究多重繼承的缺點：
菱形繼承是多繼承的一種情況，繼承方式如圖所示：
從圖中我們可以看到：
類B和類C從類A單繼承而來；
而類D從類B和類C多繼承而來。
那么這樣繼承會產生什么問題呢？
我們來看代碼：
#include <iostream>
using namespace std;
class A
{
public:
A(int data) :ma(data) { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
protected:
int ma;
};
class B :public A
{
public:
B(int data) :A(data), mb(data) { cout << "B()" << endl; }
~B() { cout << "~B()" << endl; }
protected:
int mb;
};
class C :public A
{
public:
C(int data) :A(data), mc(data) { cout << "C()" << endl; }
~C() { cout << "~C()" << endl; }
protected:
int mc;
};
class D :public B, public C
{
public:
D(int data) : B(data), C(data), md(data) { cout << "D()" << endl; }
~D() { cout << "~D()" << endl; }
protected:
int md;
};
int main()
{
D d(10);
return 0;
}
通過運行結果，我們發現了問題：
對于基類A而言，構造了兩次，析構了兩次！
并且，通過分析各個派生類的內存布局我們可以看到：
對于派生類D來說，間接繼承的基類A中的數據成員ma重復了！
這對資源來說是一種浪費與消耗。
（如果多繼承的數量增加，那么派生類中重復的數據也會增加！）
查看D類的內存布局：
其他多重繼承的情況
除了菱形繼承外，還有其他多重繼承的情況，也會出現相同的問題
比如說圖中呈現的：半圓形繼承。
如何解決多重繼承的問題
通過分析我們知道了，多重繼承的主要問題是，通過多重繼承，有可能得到重復的基類數據，并且可能重復的構造和析構同一個基類對象。
那么如何能夠避免重復現象的產生呢？
答案就是：=》虛基類。
什么是虛基類
要理解虛基類，我們首先需要認識virtual關鍵字的使用場景：
修飾成員方法時：產生虛函數；
修飾繼承方式時：產生虛基類。
對于被虛繼承的類，稱作虛基類。
比如說：
class A
{
XXXXXX;
};
class B : virtual public A
{
XXXXXX;
};
對于這個示例而言，B虛繼承了A，所以把A稱作虛基類。
虛基類如何解決問題
那么虛基類如何解決上述多重繼承產生的重復問題呢？
我們來看代碼：
#include <iostream>
using namespace std;
class A
{
public:
A(int data) :ma(data) { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
protected:
int ma;
};
class B :virtual public A
{
public:
B(int data) :A(data), mb(data) { cout << "B()" << endl; }
~B() { cout << "~B()" << endl; }
protected:
int mb;
};
class C :virtual public A
{
public:
C(int data) :A(data), mc(data) { cout << "C()" << endl; }
~C() { cout << "~C()" << endl; }
protected:
int mc;
};
class D :public B, public C
{
public:
D(int data) : B(data), C(data), md(data) { cout << "D()" << endl; }
~D() { cout << "~D()" << endl; }
protected:
int md;
};
提示說："A::A" : 沒有合適的默認構造函數可用；
為什么會這樣呢？
我們可以這么理解：
剛開始B和C單繼承A的時候，實例化對象時，會首先調用基類的構造函數，也就是A的構造函數，到了D，由于多繼承了B和C，所以在實例化D的對象時，會首先調用B和C的構造函數，然后調用自己（D）的。
但是這樣會出現A重復構造的問題，所以，采用虛繼承，把有關重復的基類A改為虛基類，這樣的話，對于A構造的任務就落到了最終派生類D的頭上，但是我們的代碼中，對于D的構造函數：D(int data) : B(data), C(data), md(data) { cout << "D()" << endl; }并沒有對A進行構造。
所以會報錯。
那么我們就給D的構造函數，調用A的構造函數：
D(int data) :A(data), B(data), C(data), md(data) { cout << "D()" << endl; }
這一次再運行
我們會發現，問題解決了。
查看虛基類的內存布局
我們可以看到當前B的內存空間：
當前B的內存空間里，前四個字節是vbptr（這個就代表里虛基類指針:virtual base ptr）;
和vfptr（虛函數指針）指向了vftable（虛函數表）一樣，
vbptr（虛基類指針）指向了vbtable（虛基類表）。
vbtable（虛基類表）的布局也如圖所示，
首先是偏移量0：表示了虛基類指針再內存布局中的偏移量；
接著是偏移量8：表示從虛基類中繼承而來的數據成員在內存中的偏移量。
對比普通繼承下的內存布局
我們可以對比沒有虛繼承下的B的內存布局來理解：
我們把他們放在一起對比可以看到：
繼承虛基類的類（B和C）會把自己從虛基類繼承而來的數據ma放在自己內存的最末尾（偏移量最大），并在原來ma的位置填充一個vbptr（虛基類指針），這個指針指向了vbtable（虛基類表）。
理解了B,我們可以看看更為復雜的D
可以看到，將ma移動到了末尾處，并在含有ma的地方，都用vbptr進行填充。
這樣一來，就只有一個ma了！解決了多重繼承的重復問題。
到此這篇關于關于C++虛函數與靜態、動態綁定的問題的文章就介紹到這了,更多相關C++虛函數與靜態、動態綁定內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://blog.csdn.net/LIJIWEI0611/article/details/120634745
