C++程式語言是一款應用廣泛，支援多種程式設計的計算機程式語言。我們今天就會為大家詳細介紹其中C++多型性的一些基本知識，以方便大家在學習過程中對此能夠有一個充分的掌握。

　　最常見的用法就是宣告基類的指標，利用該指標指向任意一個子類物件，呼叫相應的虛擬函式，可以根據指向的子類的不同而實現不同的方法。如果沒有使用虛擬函式的話，即沒有利用C++多型性，則利用基類指標呼叫相應的函式的時候，將總被限制在基類函式本身，而無法呼叫到子類中被重寫過的函式。因為沒有多型性，函式呼叫的地址將是一定的，而固定的地址將始終呼叫到同一個函式，這就無法實現一個介面，多種方法的目的了。

筆試題目：

1. #include<iostream>
2. usingnamespace std;  
3. class A  
4. {  
5. public:  
6.     void foo()  
7.     {  
8.         printf("1\n");  
9.     }  
10.     virtualvoid fun()  
11.     {  
12.         printf("2\n");  
13.     }  
14. };  
15. class B : public A  
16. {  
17. public:  
18.     void foo()  
19.     {  
20.         printf("3\n");  
21.     }  
22.     void fun()  
23.     {  
24.         printf("4\n");  
25.     }  
26. };  
27. int main(void)  
28. {  
29.     A a;  
30.     B b;  
31.     A *p = &a;  
32.     p->foo();  
33.     p->fun();  
34.     p = &b;  
35.     p->foo();  
36.     p->fun();  
37.     return 0;  
38. }  

1. //小結：1、有virtual才可能發生多型現象
2. // 2、不發生多型（無virtual）呼叫就按原型別呼叫
3. #include<iostream>
4. usingnamespace std;  
5. class Base  
6. {  
7. public:  
8.     virtualvoid f(float x)  
9.     {  
10.         cout<<"Base::f(float)"<< x <<endl;  
11.     }  
12.     void g(float x)  
13.     {  
14.         cout<<"Base::g(float)"<< x <<endl;  
15.     }  
16.     void h(float x)  
17.     {  
18.         cout<<"Base::h(float)"<< x <<endl;  
19.     }  
20. };  
21. class Derived : public Base  
22. {  
23. public:  
24.     virtualvoid f(float x)  
25.     {  
26.         cout<<"Derived::f(float)"<< x <<endl;   //多型、覆蓋
27.     }  
28.     void g(int x)  
29.     {  
30.         cout<<"Derived::g(int)"<< x <<endl;     //隱藏
31.     }  
32.     void h(float x)  
33.     {  
34.         cout<<"Derived::h(float)"<< x <<endl;   //隱藏
35.     }  
36. };  
37. int main(void)  
38. {  
39.     Derived d;  
40.     Base *pb = &d;  
41.     Derived *pd = &d;  
42.     // Good : behavior depends solely on type of the object
43.     pb->f(3.14f);   // Derived::f(float) 3.14
44.     pd->f(3.14f);   // Derived::f(float) 3.14
45.     // Bad : behavior depends on type of the pointer
46.     pb->g(3.14f);   // Base::g(float)  3.14
47.     pd->g(3.14f);   // Derived::g(int) 3 
48.     // Bad : behavior depends on type of the pointer
49.     pb->h(3.14f);   // Base::h(float) 3.14
50.     pd->h(3.14f);   // Derived::h(float) 3.14
51.     return 0;  
52. }  

　　我們先來看一些程式碼及其編譯結果。

　例項一:

　
　　#include "stdafx.h"
　　#include <iostream.h>

　　class CB
　　{
　　public:
 　　　　void f(int)
 　　　　{
 　　　　　　 cout << "CB::f(int)" << endl;
　　　　 }
　　};

　　class CD : public CB
　　{
　　public:
　　　　 void f(int,int)
 　　　　{
  　　　　　　cout << "CD::f(int,int)" << endl;
 　　　　}
 　　　　void test()
 　　　　{
  　　　　　f(1);
 　　　　}
　　};

　int main(int argc, char* argv[])
　{
　　　 return 0;
　}

編譯了一下
error C2660: 'f' : function does not take 1 parameters

結論：在類CD這個域中，沒有f(int)這樣的函式，基類中的void f(int)被隱藏

　　如果把派生CD中成員函式void f(int,int)的宣告改成和基類中一樣，即f(int)，基類中的void f(int)還是一樣被覆蓋，此時編譯不會出錯，在函式中test呼叫的是CD中的f(int)　

　　所以，在基類中的某些函式，如果沒有virtral關鍵字，函式名是f(引數是什麼我們不管)，那麼如果在派生類CD中也聲明瞭某個f成員函式，那麼在類CD域中，基類中所有的那些f都被隱藏。
　　如果你比較心急，想知道什麼是隱藏，看文章最後的簡單說明，不過我建議你還是一步一步看下去。

　　我們剛才說的是沒有virtual的情況，如果有virtual的情況呢？？
　　例項二：

#include "stdafx.h"
#include <iostream.h>

class CB
{
public:
 　　virtual void f(int)
 　　{
  　　　　cout << "CB::f(int)" << endl;
 　　}
};

class CD : public CB
{
public:
　　 void f(int)
 　　{
  　　　　cout << "CD::f(int)" << endl;
　　 }
};

int main(int argc, char* argv[])
{
 　return 0;
}

　　這麼寫當然是沒問題了，在這裡我不多費口舌了，這是很簡單的，多型，虛擬函式，然後什麼指向基類的指標指向派生類物件阿，通過引用呼叫虛擬函式阿什麼的，屬性多的很咯，什麼？？你不明白？？隨便找本C++的書，對會講多型和虛擬函式機制的哦！！
　　這種情況我們叫覆蓋(override)！覆蓋指的是派生類的虛擬函式覆蓋了基類的同名且引數相同的函式！
　　在這裡，我要強調的是，這種覆蓋，要滿足兩個條件
　(a)有virtual關鍵字，在基類中函式宣告的時候加上就可以了
　(b)基類CB中的函式和派生類CD中的函式要一模一樣，什麼叫一模一樣，函式名，引數，返回型別三個條件。
　　有人可能會對(b)中的說法質疑，說返回型別也要一樣？？
　　是，覆蓋的話必須一樣，我試了試，如果在基類中,把f的宣告改成virtual int f(int)，編譯出錯了
　　error C2555: 'CD::f' : overriding virtual function differs from 'CB::f' only by return type or calling convention
　　所以，覆蓋的話，必須要滿足上述的(a)(b)條件

　　那麼如果基類CB中的函式f有關鍵字virtual　，但是引數和派生類CD中的函式f引數不一樣呢，
例項三:
 

 #include "stdafx.h"
#include <iostream.h>

class CB
{
　public:
 　　 virtual  void f(int)
　　 {
 　　　　 cout << "CB::f(int)" << endl;
　　 }
};


class CD : public CB
{
public:
 　　 void f(int，int)
 　　{
 　　　 cout << "CD::f(int，int)" << endl;
 　　}

 　　void test()
 　　{
 　　　　 f(1);
 　　}
};

int main(int argc, char* argv[])
{
 return 0;
}

編譯出錯了，
 error C2660: 'f' : function does not take 1 parameters
　　咦？？好面熟的錯？？對，和例項一中的情況一樣哦，結論也是基類中的函式被隱藏了。

　　通過上面三個例子，得出一個簡單的結論
如果基類中的函式和派生類中的兩個名字一樣的函式f
滿足下面的兩個條件
(a)在基類中函式宣告的時候有virtual關鍵字
(b)基類CB中的函式和派生類CD中的函式一模一樣，函式名，引數，返回型別都一樣。
那麼這就是叫做覆蓋(override)，這也就是虛擬函式，多型的性質

那麼其他的情況呢？？只要名字一樣，不滿足上面覆蓋的條件，就是隱藏了。

下面我要講最關鍵的地方了，好多人認為，基類CB中的f(int)會繼承下來和CD中的f(int,int)在派生類CD中構成過載，就像例項一中想像的那樣。
　　對嗎？我們先看過載的定義
　　過載(overload):
　　必須在一個域中,函式名稱相同但是函式引數不同,過載的作用就是同一個函式有不同的行為,因此不是在一個域中的函式是無法構成過載的,這個是過載的重要特徵
　　必須在一個域中，而繼承明顯是在兩個類中了哦，所以上面的想法是不成立的，我們測試的結構也是這樣，派生類中的f(int,int)把基類中的f(int)隱藏了
　　所以，相同的函式名的函式，在基類和派生類中的關係只能是覆蓋或者隱藏。

　　在文章中，我把過載和覆蓋的定義都給了出來了，但是一直沒有給隱藏的定義，在最後，我把他給出來，這段話是網上google來的，比較長，你可以簡單的理解成，在派生類域中，看不到基類中的那個同名函數了，或者說，是並沒有繼承下來給你用，呵呵，如例項一　那樣。
　　

隱藏(hide):
指的是派生類的成員函式隱藏了基類函式的成員函式.隱藏一詞可以這麼理解:在呼叫一個類的成員函式的時候,編譯器會沿著類的繼承鏈逐級的向上查詢函式的定義,如果找到了那麼就停止查找了,所以如果一個派生類和一個基類都有同一個同名(暫且不論引數是否相同)的函式,而編譯器最終選擇了在派生類中的函式,那麼我們就說這個派生類的成員函式"隱藏"了基類的成員函式,也就是說它阻止了編譯器繼續向上查詢函式的定義.