多型

所謂多型，其實就是“多種形態”，C++的多型分為靜態多型和動態多型。
1. 靜態多型就是過載，因為是在編譯期決議確定，所以稱為靜態多型。
2. 動態多型就是通過繼承重寫基類的虛擬函式實現的多型，因為是在運⾏時決議確定，所以稱為動態多型。

C++中虛擬函式的主要作⽤——就是實現多型。簡單說⽗類的指標/引⽤調⽤重寫的虛擬函式，當⽗類指標/引⽤指向⽗類物件時調⽤的是⽗類的虛擬函式，指向⼦類物件時調⽤的是⼦類的虛擬函式。
ps:父類即基類，子類即派生類。

虛擬函式
虛擬函式的定義在父類中進行，它是在父類中需要定義為虛擬函式的成員函式的宣告中冠以關鍵字 virtual ,從而提供一種介面介面。並且虛擬函式可以在一個或者多個子類

#include<iostream>
using namespace std;
class Grandma
{
public:
    virtual void introduce_self()
    {
        cout << "I am Grandma" << endl; 
    }
};
class Mother:public
 
 Grandma
{
public:
     void introduce_self()
   {
           cout << "I am Mother" << endl;
   }
};
class Daughter :public Mother
{
public:
     void introduce_self()
    {
        cout << "I am Daughter" << endl;
    }
};
int main()
{
    Grandma* ptr;
    Grandma g;
    Mother m;
    Daughter d;
    ptr = &g;
    ptr->introduce_self();
    ptr = &m;
    ptr->introduce_self();
    ptr = &d;
    ptr->introduce_self();
    system("pause"
 
);
    return 0;
}

結果如下：

程式只有Grandma中顯式定義了introduce_self（）是虛擬函式。C++中規定，若沒有virtual顯式宣告，將依據以下條件判斷是否是虛擬函式。1、該函式與虛擬函式有相同名稱。2、該函式與虛擬函式有相同引數個數及相同對應引數型別3、該函式與虛擬函式有相同返回值型別或者滿足賦值相容規則的指標、引用型別的返回值。

賦值相容規則
1. ⼦類物件可以賦值給⽗類物件（切割/切⽚）
2. ⽗類物件不能賦值給⼦類物件
3. ⽗類的指標/引⽤可以指向⼦類物件
4. ⼦類的指標/引⽤不能指向⽗類物件（可以通過強制型別轉換完成）
ps:純虛擬函式—— 宣告純虛擬函式一般形式如下：
virtual 函式型別 函式名（引數表）=0；
純虛擬函式不具備函式的功能，不能被呼叫。因為包含至少一個純虛擬函式的抽象類不能例項化出物件。

虛擬函式表
虛擬函式表是通過⼀塊連續記憶體來儲存虛擬函式的地址。這張表解決了繼承、虛擬函式(重寫)的問題。在有虛擬函式的物件例項中都存在⼀張虛擬函式表，虛擬函式表就像⼀張地圖，指明瞭實際應該調⽤的虛擬函式。虛擬函式表的地址可以通過記憶體視窗看到。

以單繼承虛表舉例：

#include<iostream>
using namespace std;

class Base
{
public:
    virtual void func1()
    {
        cout << "Base::func1" << endl;
    }
    virtual void func2()
    {
        cout << "Base::func2" << endl;
    }
private:
    int a;
};
class Derive :public Base
{
public:
    virtual void func1()
    {
        cout << "Derive::func1" << endl;
    }
    virtual void func3()
    {
        cout << "Derive::func3" << endl;
    }
    virtual void func4()
    {
        cout << "Derive::func4" << endl;
    }
private:
    int b;
};
typedef void(*FUNC) ();

void PrintVTable(int* VTable)
{
    cout << "虛表地址>" << VTable << endl;
    for (int i = 0; VTable[i] != 0; ++i)
    {
        printf(" 第%d個虛擬函式地址 :0X%x,->", i, VTable[i]);
        FUNC f = (FUNC)VTable[i];
        f();
    }
    cout << endl;
}
void Test1()
{
    Base b1;
    Derive d1;
    int* VTable1 = (int*)(*(int*)&b1);
    int* VTable2 = (int*)(*(int*)&d1);
    PrintVTable(VTable1);
    PrintVTable(VTable2);
}
int main()
{
    Test1();
    system("pause");
    return 0;
}

可以看到派⽣類Derive::func1重寫基類Base::func1，覆蓋了相應虛表位置上的函式。
ps:可以看到這⾥沒有看到派⽣類Derive中的func3和func4，這兩個函式就放在func2的後⾯，這⾥沒有顯⽰是VS的問題（bug）。
下面的圖有助於更好理解。

那麼多繼承在記憶體中佈局是怎樣的？下面例子告訴你 ！

#include<iostream>
using namespace std;

class Base1
{
public:
    virtual void func1()
    {
        cout << "Base::func1()" << endl;
    }
    virtual void func2()
    {
        cout << "Base::func2()" << endl;
    }
public:
    int b1;
};
class Base2
{
public:
    virtual void func1()
    {
        cout << "Base::func1()" << endl;
    }
    virtual void func3()
    {
        cout << "Base::func3()" << endl;
    }
public:
    int b2;

};
class Derive:public Base1,public Base2
{
public:
    virtual void func1()
    {
        cout << "Derive::func1()" << endl;
    }
    virtual void func4()
    {
        cout << "Derive::func4()" << endl;
    }
public:
    int d1;
};

typedef void(*FUNC) ();

void PrintVTable(int* Vtable)
{
    cout << "虛表地址>" << Vtable << endl;
    int ** ppvtable = (int**)Vtable;
    for (int i = 0; ppvtable[i] != 0; ++i)
    {
        printf(" 第%d個虛擬函式地址 :0X%x,->", i, ppvtable[i]);
        FUNC f = (FUNC)ppvtable[i];
        f();
    }
    cout << endl;
}
void Test1()
{
    Derive  d;
    d.b1 = 1;
    d.b2 = 2;
    d.d1 = 3;

    PrintVTable(*((int**)(&d)));

    // Base2虛擬函式表在物件Base1後⾯
    PrintVTable(*((int**)((char*)&d + sizeof(Base1))));
}
int main()
{
    Test1();
    system("pause");
    return 0;
}

在多繼承模型中我們在列印虛擬函式表時應注意型別的轉換和不同虛表在記憶體中的佈局關係。在之後的菱形繼承模型中，我們會用到虛繼承來解決二義性和資料冗餘問題，對記憶體佈局加以更深瞭解。