C++多態篇2——虛函數表詳解之從內存布局看函數重載，函數覆蓋，函數隱藏

class Base
{
public:
    Base(int data = 1)
        :b(data)
    {
        cout << "Base()" << endl;
    }
    ~Base()
    {
        cout << "~Base()" << endl;
    }
    virtual void Test1()
    {
        cout << "Base::Test1()" << endl;
    }
    virtual void Test2()
    {
        cout << "Base::Test2()" << endl;
    }
    virtual void Test3()
    {
        cout << "Base::Test3()" << endl;
    }
    int b;
};
class Derive :public Base
{
public:
    Derive(int data = 2)
        :d(data)
    {
        cout << "Derive()" << endl;
    }
    ~Derive()
    {
        cout << "~Derive()" << endl;
    }
    void Test1()
    {
        cout << "Derive::Test1()" << endl;
    }   
    void Test2()
    {
        cout << "Derive::Test2()" << endl;
    }
    int d;
};

int main()
{
    Base b;
    b.Test1();
    b.Test2();
    b.Test3();
    Derive d;
    d.Test1();
    d.Test2();
    d.Test3();
    return 0;
}

從代碼可以看出在基類定義了三個虛函數，根據我們以前所說的知識，我們可以猜測基類會生成一個虛函數表，那麼派生類中我們定義了兩個同名同參數的函數，為了讓函數覆蓋的現象更加明顯，我特意沒有將Test3（）定義，那麼我們現在看一下運行結果：

由結果可知，基類對象調用的是基類的函數。派生類對象調用的是什麼呢？
我們進入內存中查看一下：

由上圖我們可以看到，我們在派生類中定義了的函數，在派生類虛函數表中將基類函數覆蓋了，即派生類虛函數表中綠色的部分，而派生類沒有定義的函數，即Test3（），基類和派生類的函數地址完全相同。
這就更清楚的看出了，派生類中定義了同名同參數的函數後，發生了函數覆蓋。
2.指針或引用調用函數的情況
指向派生類的基類指針調用的也是派生類的覆蓋函數
還是上面的例子，我們將調用者換一下：

class Base
{
public:
    Base(int data = 1)
        :b(data)
    {
        cout << "Base()" << endl;
    }
    ~Base()
    {
        cout << "~Base()" << endl;
    }
    virtual void Test()
    {
        cout << "Base::Test()" << endl;
    }
    int b;
};
class Derive :public Base
{
public:
    Derive(int data = 2)
        :d(data)
    {
        cout << "Derive()" << endl;
    }
    ~Derive()
    {
        cout << "~Derive()" << endl;
    }
    void Test()
    {
        cout << "Derive::Test()" << endl;
    }
    int d;
};

int main()
{
    Base *pb;
    Derive d;
    pb = &d;
    pb->Test();
    return 0;
}

運行結果為：

在內存布局為：

由內存布局可以看出，指針pb指向的虛表就是派生類對象d所擁有的虛表，所以當然調用的是派生類已經覆蓋了的函數。
所以說：
多態的本質：不是重載聲明而是覆蓋。
虛函數調用方式：通過基類指針或引用，執行時會根據指針指向的對象的類，決定調用哪個函數。
三、函數隱藏
經過上面的分析我們知道，在不同的類域定義不同參數的同名函數，是無法構成函數重載的。
那麼當我們這麼做的時候，會發生什麼呢。
實際上，這種情況叫做函數隱藏。
* 隱藏”是指派生類的函數屏蔽了與其同名的基類函數，規則如下*
（1）如果派生類的函數與基類的函數同名，並且參數也相同，但是基類函數沒有virtual 關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）
（2）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數將被隱藏（注意別與重載混淆）。
首先來看第一種情況。
1.同名同參數
那麼在上面的例子中我們試一下不加virtual關鍵字看看。
即將基類改為：

class Base
{
public:
    Base(int data = 1)
        :b(data)
    {
        cout << "Base()" << endl;
    }
    ~Base()
    {
        cout << "~Base()" << endl;
    }
    void Test()
    {
        cout << "Base::Test()" << endl;
    }
    int b;
};
class Derive :public Base
{
public:
    Derive(int data = 2)
        :d(data)
    {
        cout << "Derive()" << endl;
    }
    ~Derive()
    {
        cout << "~Derive()" << endl;
    }
    void Test()
    {
        cout << "Derive::Test()" << endl;
    }
    int d;
};

int main()
{
    Derive d;
    d.Test();
    return 0;
}

運行結果還是：

這就是發生了函數的隱藏
再看下第二種情況
2.同名不同參數
（1）基類函數不加virtual

class Base
{
public:
    Base(int data = 1)
        :b(data)
    {
        cout << "Base()" << endl;
    }
    ~Base()
    {
        cout << "~Base()" << endl;
    }
    void Test()
    {
        cout << "Base::Test()" << endl;
    }
    int b;
};
class Derive :public Base
{
public:
    Derive(int data = 2)
        :d(data)
    {
        cout << "Derive()" << endl;
    }
    ~Derive()
    {
        cout << "~Derive()" << endl;
    }
    void Test(int a)
    {
        cout << "Derive::Test()" << endl;
    }
    int d;
};

int main()
{
    Derive d;
    d.Test();
    return 0;
}

我們在基類中定義了Test（）函數，在派生類中定義了Test（int a）函數，這就是同名不同參數情況。
編譯運行一下：
編譯器報錯：

Error   1   error C2660: 'Derive::Test' : function does not take 0 arguments    e:\demo\blog\project1\project1\source.cpp   105 1   Project1

我們可以看出，編譯器報錯：Test函數不能為0參數。
如果我們將main函數改變一下：

int main()
{
    Derive d;
    d.Test(1);
    return 0;
}

運行成功，結果為：

這就是發生了函數隱藏~
（2）基類函數加virtual

class Base
{
public:
    Base(int data = 1)
        :b(data)
    {
        cout << "Base()" << endl;
    }
    ~Base()
    {
        cout << "~Base()" << endl;
    }
    virtual void Test()
    {
        cout << "Base::Test()" << endl;
    }
    int b;
};
class Derive :public Base
{
public:
    Derive(int data = 2)
        :d(data)
    {
        cout << "Derive()" << endl;
    }
    ~Derive()
    {
        cout << "~Derive()" << endl;
    }
    void Test(int a)
    {
        cout << "Derive::Test()" << endl;
    }
    int d;
};

int main()
{
    Derive d;
    d.Test();
    return 0;
}

編譯運行依然報錯：

Error   1   error C2660: 'Derive::Test' : function does not take 0 arguments    e:\demo\blog\project1\project1\source.cpp   105 1   Project1

那麼將main函數改變一下：

int main()
{
    Derive d;
    d.Test(1);
    return 0;
}

運行成功，結果為：

這也是發生了函數隱藏。
現在函數隱藏應該沒有問題了吧~
總結一下前面的：
1.函數重載必須是在同一作用域的，在繼承與多態這裡，在基類與派生類之間是不能進行函數重載。
2.函數覆蓋是多態的本質，在基類中的虛函數，在派生類定義一個同名同參數的函數，就可以用派生類新定義的函數對基類函數進行覆蓋。
3.函數隱藏是發生在基類和派生類之間的，當函數同名但是不同參數的時候，不論是不是虛函數，都會發生函數隱藏。
這篇文章就暫且寫到這裡，本來是想對虛函數表進行深度剖析的，但是寫那一篇的時候發現，會用到這裡的知識，害怕初學者這裡還不清楚，所以現將這些問題整理一下，再更新下一篇文章。
如有問題歡迎批評指正，人無完人，文無完文，希望大家共同進步！