C++ 中函數重載、覆蓋與隱藏詳解

在C++語言中，函數扮演著很重要的角色，不管面向過程設計，還是基于對象設計；不管是面向對象編程，還是基于泛型編程，函數都可以隨處而見。在談論C++中的函數重載、覆蓋和隱藏之前，先回顧下函數的基礎知識。

成員函數的重載、覆蓋與隱藏

成員函數的重載、覆蓋（override）與隱藏很容易混淆，C++程序員必須要搞清楚
概念，否則錯誤將防不勝防。

8.2.1 重載與覆蓋

成員函數被重載的特征：
（1）相同的范圍（在同一個類中）；
（2）函數名字相同；
（3）參數不同；
（4）virtual 關鍵字可有可無。

覆蓋是指派生類函數覆蓋基類函數，特征是：

（1）不同的范圍（分別位于派生類與基類）；
（2）函數名字相同；
（3）參數相同；
（4）基類函數必須有virtual 關鍵字。

示例8-2-1 中，函數Base::f(int)與Base::f(float)相互重載，而Base::g(void)

被Derived::g(void)覆蓋。

#include <iostream>
using namespace std;
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};
class Derived : public Base
{
public:
virtual void g(void){ cout << "Derived::g(void)" << endl;}
};
void main(void)
{
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)
}

示例8-2-1 成員函數的重載和覆蓋

8.2.2 令人迷惑的隱藏規(guī)則

本來僅僅區(qū)別重載與覆蓋并不算困難，但是C++的隱藏規(guī)則使問題復雜性陡然增加。

這里“隱藏”是指派生類的函數屏蔽了與其同名的基類函數，規(guī)則如下：
（1）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual
關鍵字，基類的函數將被隱藏（注意別與重載混淆）。
（2）如果派生類的函數與基類的函數同名，并且參數也相同，但是基類函數沒有virtual
關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）。

示例程序8-2-2（a）中：

（1）函數Derived::f(float)覆蓋了Base::f(float)。
（2）函數Derived::g(int)隱藏了Base::g(float)，而不是重載。
（3）函數Derived::h(float)隱藏了Base::h(float)，而不是覆蓋。

#include <iostream>
using namespace std;
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:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
};

示例8-2-2（a）成員函數的重載、覆蓋和隱藏
據作者考察，很多C++程序員沒有意識到有“隱藏”這回事。由于認識不夠深刻，
“隱藏”的發(fā)生可謂神出鬼沒，常常產生令人迷惑的結果。
示例8-2-2（b）中，bp 和dp 指向同一地址，按理說運行結果應該是相同的，可事
實并非這樣。

void main(void)
{
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
}

示例8-2-2（b） 重載、覆蓋和隱藏的比較

8.2.3 擺脫隱藏

隱藏規(guī)則引起了不少麻煩。示例8-2-3 程序中，語句pd->f(10)的本意是想調用函
數Base::f(int)，但是Base::f(int)不幸被Derived::f(char *)隱藏了。由于數字10
不能被隱式地轉化為字符串，所以在編譯時出錯。

class Base
{
public:
void f(int x);
};
class Derived : public Base
{
public:
void f(char *str);
};
void Test(void)
{
Derived *pd = new Derived;
pd->f(10); // error
}

下面是補充大家可以參考一下

函數的聲明包括函數的返回值類型，函數名稱，參數列表（參數的類型、參數的個數、參數的順序）。例如，聲明一個兩個整數之和的函數，int iAdd(int iNum1,int iNum2);而函數的定義可以理解為對函數功能的詳盡而準確的解說，通俗點，就是實現函數“how to do？”的效能。兩個整數之和函數的定義如下：

int iAdd(int iNum1,int iNum2)
{
   return (iNum1+iNum2);
}

       仔細觀察函數的聲明和定義，我們不難發(fā)現，函數的定義就是除掉函數聲明后面的分號，換之成大括號，在大括號里面實現函數的功能。雖然在某些情況下，可以容許不對函數進行聲明，只需要對函數定義，就能調用函數了。但是，強烈建議養(yǎng)成先聲明函數，然后再定義函數，最后在調用函數的良好習慣。關于函數的基礎知識，暫時論述到這。

       現在，進入本文的主題。函數重載（function overload），它是在同一可訪問區(qū)域內部聲明具有幾個不同參數列（參數的類型、參數的個數，參數的順序）的相同函數名稱的一種機制，函數的調用是根據不同的參數類型和最佳匹配原則確定最終使用那個函數。函數覆蓋（function override）是在派生類中完全一致性地聲明了父類中的函數，區(qū)別在于函數定義中的大括號之間的內容可以不同，并且該函數在父類中有關鍵字virtual標識；函數隱藏（function hide）是指在派生類中函數與父類函數完全一致，但是在父類中該函數沒有關鍵字virtual標識，或者是指在派生類中函數與父類的函數名相同，參數列表不一樣，父類中的該函數可有也可無關鍵字virtual標識。

函數重載的特征：相同的范圍內（在同一個類中），函數的名稱相同，參數列表不同，virtual關鍵字可有可無；函數覆蓋的特征：在不同的范圍內（父類與派生類），函數的名字相同，參數列表相同，父類函數必須有關鍵字virtual；函數隱藏的特征：在不同范圍內（父類與派生類），函數的名字相同，參數列表相同，但是父類函數沒有關鍵字virtual或者，參數列表不相同，父類函數中virtual關鍵字可有可無。

為了直觀地理解，請看下面的代碼。

#include<iostream>
using namespace std;
class A
{
public:
   void print(int iNum)
   {
     cout<<"在類A中，參數類型是整型"<<endl;
   }
   void print(float fNum)
   {
     cout<<"在類A中，參數類型是單精度浮點型"<<endl;
   }
 virtual void print(void)
   {
     cout<<"在類A中，參數類型是空類型"<<endl;
   }
};
class B:public A
{
public:
   void print( void)
   {
     cout<<"在類B中，參數類型是空類型"<<endl;
   }
 
   void print(int iNum)
   {
     cout<<"在類B中，參數類型是整型"<<endl;
   }
 };
int main()
{
   A a;
   B b;
  //函數的重載
   a.print();
   a.print(1);
   a.print(1.0f);
  //函數的覆蓋
   b.print();
 //函數的隱藏
   b.print(1);
  return 0;
}

      運行結果是：

   在類A中，參數類型是空類型
   在類A中，參數類型是整型
   在類A中，參數類型是單精度浮點型
   在類B中，參數類型是空類型
   在類B中，參數類型是整型

     通過上述代碼和運行的結果，簡明地知道了函數重載，覆蓋和隱藏。恰當里利用這些特性，可以編寫出更加有效、清晰和精簡的代碼。                           

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

最新評論