1.重載，在同一個作用域中定義的同名不同參的一些函數為重載。

2.隱藏，若在基類中定義了某一non_virtual函數，在派生類重存在同名函數（不需要參數列表相同），基類的該函數在派生類中是不可見的，如若用派生類的實例化對象調用基類的該函數會編譯錯誤。此種情況即為隱藏，指基類的函數在派生類中隱藏了，編譯器找不到這個函數。

3.覆蓋，如果基類中的某一函數被聲明為虛函數，那么在派生類中如果重新定義了這個虛函數，那么我們說該函數在派生類中被覆蓋了。用指向派生類的基類指針訪問該函數只能調用派生類的該函數。

class Base { public:Base(){std::cout << "Base Constructor" << std::endl;}virtual ~Base(){std::cout << "Base Destructor" << std::endl;}public:void f() //不帶參數的f函數{cout << 0 << endl;}void f(int a) //帶一個參數的f函數{cout << a << endl;}protected:std::string Bmsg; };class Derive : public Base { public:Derive(){std::cout << "Derive Constructor" << std::endl;}~Derive(){std::cout << "Derive Destructor" << std::endl;}public:void f(int a, int b) //帶兩個參數的f函數{cout << a + b << endl;}private:std::string Dmsg; };int main() {Base b;std::cout << std::endl;Derive d;std::cout << std::endl;Base * pb = new Derive;std::cout << std::endl;b.f(); //OKb.f(1); //OKd.f(); //errord.f(1); //errord.f(1, 2); //OKdelete pb;pb = NULL;return 0; }
本例中，我們定義了基類的實例化對象b，派生類的實例化對象d。

Base b; Derive d;

b.f(); //OKb.f(1); //OK

基類的實例化對象調用自身的函數通過編譯，我們說在基類中f函數被重載了。

d.f(); //errord.f(1); //error通過派生類的實例化對象調用基類的f函數，因為在派生類中額外定義了一個同名函數f，我們說在派生類中基類的f函數被隱藏了，從而在派生類中這些函數不可見，編譯器找不到這些函數，所以無法調用。
d.f(1, 2); //OK通過派生類的對象調用自身的函數通過編譯，如前所述，這個函數的定義導致基類的同名函數被隱藏了。

當然，如果非要在上述條件中使用基類被隱藏的函數話，可以使用using關鍵字來進行標識，具體做法如下：

public:using Base::f;像這樣，因為f是public作用域中，所以我們在派生類的public作用域中添加using Base::f;這條語句就相當于我們認為地告訴編譯器基類中的f函數是可見的。

d.f();d.f(1);d.f(1, 2);
這樣就可以用派生類的實例化對象調用三個f函數了。

上述內容對于虛函數同樣適用，但只適用于用實例化對象訪問成員函數的情況，

而對于使用多態指針的情況，即本例中定義的pb變量，請看下面的測試：

pb->f(); //OKpb->f(1); //OKpb->f(1, 2); //error
我們發現，如果調用的不是虛函數，使用指針的情況和實例化對象是相同的，編譯器訪問的作用域就是該指針的靜態類型，本例中pb的靜態類型是Base類型，因為Base中沒有接收兩個參數的f函數，所以不能通過編譯。

下面討論多態指針和虛函數的情況，我們需要改造一下類的定義：

#include <iostream> using namespace std; class Base { public:Base(){std::cout << "Base Constructor" << std::endl;}virtual ~Base(){std::cout << "Base Destructor" << std::endl;}public:void f(){cout << 0 << endl;}void f(int a){cout << a << endl;}virtual void g() //虛函數，不帶參數{cout << "Base" << endl;}virtual void g(int a) //虛函數，帶一個參數{cout << "Base" << a << endl;}protected:std::string Bmsg; };class Derive : public Base { public:Derive(){std::cout << "Derive Constructor" << std::endl;}~Derive(){std::cout << "Derive Destructor" << std::endl;}public://using Base::f;void f(int a, int b){cout << a + b << endl;}void g() //派生類中繼承虛函數性質，不帶參數{cout << "Derive" << endl;}void g(int a, int b) //同上，帶兩個參數{cout << "Derive" << a << " " << b << endl;} private:std::string Dmsg; };int main() {Base b;std::cout << std::endl;Derive d;std::cout << std::endl;Base * pb = new Derive;std::cout << std::endl;pb->g(); //輸出"Derive"pb->g(1); //輸出"Base1"pb->g(1, 2); //errordelete pb;pb = NULL;return 0; }
這個例子中在基類中增加了函數名為g的虛函數，分別是不帶參數和帶一個參數，如前所述，這兩個函數在基類中被重載。

現在討論用指針來訪問成員函數的問題，此時pb是一個指向派生類的基類指針：

pb->g(); //輸出"Derive"

編譯器在處理指針問題的時候，會先判斷該指針指向的對象類型，本例中指向的是派生類，所以先去派生類的作用域中尋找最佳匹配的函數（即函數名和參數列表都匹配），因為我們在派生類中定義了不帶參數的g函數，所以可以通過編譯，輸出"Derive"。

pb->g(1); //輸出"Base1"

在第一種情況下，如果編譯器沒有找到匹配的函數，會向上進入到其基類的作用域中尋找，本例在基類中找到帶有一個參數的g函數，所以通過編譯，輸出"Base1"。

pb->g(1, 2); //error

如果按照前面兩條所述，那么這條語句按理說應該會通過編譯才對，因為在派生類中找到了這樣的函數。

但是這只是表面現象，編譯器真的可以找到這樣的函數嗎。我們知道，在進行多態調用函數的時候是通過虛函數表來尋找匹配函數的。在定義了一個指向派生類的基類指針時，會在分配到的內存最開始處存放所有基類虛函數的地址，然后掃描派生類，如果派生類重新定義了某個虛函數，那么會更新虛函數表，將表中這個虛函數的地址替換成派生類中該虛函數的地址。也就是之前說的覆蓋。

然而如果在基類中本來就不存在某一個虛函數，而在派生類中卻存在這樣的虛函數，那么掃描派生類的時候就不會更新虛函數表，表中就沒有該函數的地址，編譯器自然是找不到這個函數的。所以無法通過編譯。

可以理解為指向派生類的基類指針可以調用派生類的虛函數，但是這些虛函數必須在基類中同樣存在。

總結

以上是生活随笔為你收集整理的C++学习笔记-----继承体系中函数的重载，覆盖和隐藏的区别的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。