C++ 中函數(shù)重載、覆蓋與隱藏詳解

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

成員函數(shù)的重載、覆蓋與隱藏

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

8.2.1 重載與覆蓋

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

覆蓋是指派生類函數(shù)覆蓋基類函數(shù)，特征是：

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

示例8-2-1 中，函數(shù)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 成員函數(shù)的重載和覆蓋

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

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

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

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

（1）函數(shù)Derived::f(float)覆蓋了Base::f(float)。
（2）函數(shù)Derived::g(int)隱藏了Base::g(float)，而不是重載。
（3）函數(shù)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）成員函數(shù)的重載、覆蓋和隱藏
據(jù)作者考察，很多C++程序員沒有意識到有“隱藏”這回事。由于認識不夠深刻，
“隱藏”的發(fā)生可謂神出鬼沒，常常產(chǎn)生令人迷惑的結果。
示例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)的本意是想調用函
數(shù)Base::f(int)，但是Base::f(int)不幸被Derived::f(char *)隱藏了。由于數(shù)字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
}

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

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

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

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

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

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

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

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

      運行結果是：

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

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

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

最新評論