C++成員函式的過載、覆蓋和隱藏

1. 過載與覆蓋

成員函式被過載的特徵是：

• 具有相同的作用域（即同一個類定義中）；
• 函式名字相同；
• 引數型別、順序或數目不同（包括）；
• virtual 關鍵字可有可無。

覆蓋是指派生類重新實現（或者改寫）了基類的成員函式，其特徵是：

• 不同的作用域（分別位於派生類和基類中）；
• 函式名稱相同；
• 引數列表完全相同；
• 基類函式必須是虛擬函式。

#pragma once

#include <iostream>

using namespace std;

// 展示了 Overload 和 Override

class Base
{
public
 
:
    void f(int x) { cout << "Base::f(int) " << x << endl; }
    // overload Base::f(int x)
    void f(float x) { cout << "Base::f(float) " << x << endl; }
    virtual void g(void) { cout << "Base::g(void)" << endl; }
};
class Derived : public Base
{
public
 
:
    // override Base::g(void)
    virtual void g(void) { cout << "Derived::g(void)" << endl; }
};

void test()
{
    Derived d;
    Base *pb = &d;
    pb->f(42);      // Base::f(int) 42
    pb->f(3.14f);   // Base::f(float) 3.14
    pb->g();        // Derived::g(void)
}

注：

1. virtual 關鍵字告訴編譯器，派生類中相同的成員函式應該放到 vtable 中，並替換基類相應成員函式的槽位；
2. 虛擬函式的覆蓋有兩種方式：完全重寫和擴充套件。擴充套件是指派生類虛擬函式首先呼叫基類的虛擬函式，然後在增加新的功能。

2. 令人迷惑的隱藏規則

隱藏是指派生類的成員函式遮蔽了與其同名的基類成員函式，具體規則如下：

• 派生類的函式與基類的函式同名，但是引數列表有所差異，此時，不論有無 virtual 關鍵字，基類的函式在派生類中將被隱藏（注意別於過載混淆）；
• 派生類的函式與基類的函式同名，引數列表也相同，但是基類函式沒有 virtual 關鍵字。此時，基類的函式在派生類中將被隱藏（注意別與覆蓋混淆）。

#pragma once

#include <iostream>

using namespace std;

// 展示了 Override 和 Hide

class Base
{
public:
    virtual void f(float x) { cout << "Base::f(float) " << x << endl; }
    void g(float x) { cout << "Base::g(float) " << x << endl; }
    void h(float x) { cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{
public:
    // override Base::f()
    virtual void f(float x) { cout << "Derived::f(float) " << x << endl; }
    // hide Base::g()
    void g(int x) { cout << "Derived::g(int) " << x << endl; }
    // hide Base::h()
    void h(float x) { cout << "Derived::h(float) " << x << endl; }
};

void test()
{
    Derived d;
    Base *pb = &d;
    Derived *pd = &d;
    // Good : behavior depends solely on type of the object
    pb->f(3.14f); // Derived::f(float) 3.14
    pd->f(3.14f); // Derived::f(float) 3.14
    // Bad : behavior depends on type of the pointer
    pb->g(3.14f); // Base::g(float) 3.14
    pd->g(3.14f); // Derived::g(int) 3 (surprise!)
    // Bad : behavior depends on type of the pointer
    pb->h(3.14f); // Base::h(float) 3.14 (surprise!)
    pd->h(3.14f); // Derived::h(float) 3.14
}

注：如果你確實想使用所謂的“跨越類邊界的過載”，可以在派生類定義中的任何地方顯示地使用 using 關鍵字，如下：

class Derived: public Base{
public:
    using Base::g;
    void g(int x) {...}
}

3. 擺脫隱藏

隱藏規則引起不少麻煩。下面程式碼中，程式設計師可能期望語句 pd->f(10) 呼叫 Base::f(int)，但是 Base::f(int) 不幸被Derived::f(char) 隱藏了。由於數字 10 不能被隱式地轉換為字串型別，所以在編譯時出錯。

#pragma once

#include <iostream>

using namespace std;

// 展示了 Hide 所帶來的麻煩

class Base
{
public:
    void f(int x) { cout << x << endl; }
};
class Derived : public Base
{
public:
    // hide Base::f(int)
    void f(char *str) { cout << str << endl; }

    // 擺脫隱藏法一
    //using Base::f;

    // 擺脫隱藏法二
    //void f(int x) { Base::f(x); }
};

void test(void)
{
    Derived *pd = new Derived;
    pd->f(10); // error 編譯時報錯，因為Base中函式被隱藏
}

如果語句 pd->f(10) 確實想呼叫函式 Base::f(int)，那麼有兩個辦法：其一就是使用 using 宣告；其二就是把類 Derived 修改為如下的樣子。

class Derived : public Base
{
public:
    // hide Base::f(int)
    void f(char *str) { cout << str << endl; }
    // 呼叫傳遞
    void f(int x) { Base::f(x); }
};