C++中的多態

C++編程語言是一款應用廣泛，支持多種程序設計的計算機編程語言。我們今天就會為大家詳細介紹其中C++多態性的一些基本知識，以方便大家在學習過程中對此能夠有一個充分的掌握。
　　多態性可以簡單地概括為“一個接口，多種方法”，程序在運行時才決定調用的函數，它是面向對象編程領域的核心概念。多態(polymorphism)，字面意思多種形狀。
　　C++多態性是通過虛函數來實現的，虛函數允許子類重新定義成員函數，而子類重新定義父類的做法稱為覆蓋(override)，或者稱為重寫。（這裡我覺得要補充，重寫的話可以有兩種，直接重寫成員函數和重寫虛函數，只有重寫了虛函數的才能算作是體現了C++多態性）而重載則是允許有多個同名的函數，而這些函數的參數列表不同，允許參數個數不同，參數類型不同，或者兩者都不同。編譯器會根據這些函數的不同列表，將同名的函數的名稱做修飾，從而生成一些不同名稱的預處理函數，來實現同名函數調用時的重載問題。但這並沒有體現多態性。
　　多態與非多態的實質區別就是函數地址是早綁定還是晚綁定。如果函數的調用，在編譯器編譯期間就可以確定函數的調用地址，並生產代碼，是靜態的，就是說地址是早綁定的。而如果函數調用的地址不能在編譯器期間確定，需要在運行時才確定，這就屬於晚綁定。
　　那麼多態的作用是什麼呢，封裝可以使得代碼模塊化，繼承可以擴展已存在的代碼，他們的目的都是為了代碼重用。而多態的目的則是為了接口重用。也就是說，不論傳遞過來的究竟是那個類的對象，函數都能夠通過同一個接口調用到適應各自對象的實現方法。

　　最常見的用法就是聲明基類的指針，利用該指針指向任意一個子類對象，調用相應的虛函數，可以根據指向的子類的不同而實現不同的方法。如果沒有使用虛函數的話，即沒有利用C++多態性，則利用基類指針調用相應的函數的時候，將總被限制在基類函數本身，而無法調用到子類中被重寫過的函數。因為沒有多態性，函數調用的地址將是一定的，而固定的地址將始終調用到同一個函數，這就無法實現一個接口，多種方法的目的了。

筆試題目：

1. #include
2. usingnamespacestd;
3.  
4. classA
5. {
6. public:
7. voidfoo()
8. {
9. printf("1\n");
10. }
11. virtualvoidfun()
12. {
13. printf("2\n");
14. }
15. };
16. classB:publicA
17. {
18. public:
19. voidfoo()
20. {
21. printf("3\n");
22. }
23. voidfun()
24. {
25. printf("4\n");
26. }
27. };
28. intmain(void)
29. {
30. Aa;
31. Bb;
32. A*p=&a;
33. p->foo();
34. p->fun();
35. p=&b;
36. p->foo();
37. p->fun();
38. return0;
39. } 第一個p->foo()和p->fuu()都很好理解，本身是基類指針，指向的又是基類對象，調用的都是基類本身的函數，因此輸出結果就是1、2。
    　 第二個輸出結果就是1、4。p->foo()和p->fuu()則是基類指針指向子類對象，正式體現多態的用法，p->foo()由於指針是個基類指針，指向是一個固定偏移量的函數，因此此時指向的就只能是基類的foo()函數的代碼了，因此輸出的結果還是1。而p->fun()指針是基類指針，指向的fun是一個虛函數，由於每個虛函數都有一個虛函數列表，此時p調用fun()並不是直接調用函數，而是通過虛函數列表找到相應的函數的地址，因此根據指向的對象不同，函數地址也將不同，這裡將找到對應的子類的fun()函數的地址，因此輸出的結果也會是子類的結果4。
    　　筆試的題目中還有一個另類測試方法。即
    B *ptr = (B *)&a; ptr->foo(); ptr->fun();
    　　問這兩調用的輸出結果。這是一個用子類的指針去指向一個強制轉換為子類地址的基類對象。結果，這兩句調用的輸出結果是3，2。
    　　並不是很理解這種用法，從原理上來解釋，由於B是子類指針，雖然被賦予了基類對象地址，但是ptr->foo()在調用的時候，由於地址偏移量固定，偏移量是子類對象的偏移量，於是即使在指向了一個基類對象的情況下，還是調用到了子類的函數，雖然可能從始到終都沒有子類對象的實例化出現。
    　　而ptr->fun()的調用，可能還是因為C++多態性的原因，由於指向的是一個基類對象，通過虛函數列表的引用，找到了基類中fun()函數的地址，因此調用了基類的函數。由此可見多態性的強大，可以適應各種變化，不論指針是基類的還是子類的，都能找到正確的實現方法。
    
    1. //小結：1、有virtual才可能發生多態現象
    2. //2、不發生多態（無virtual）調用就按原類型調用
    3. #include
    4. usingnamespacestd;
    5.  
    6. classBase
    7. {
    8. public:
    9. virtualvoidf(floatx)
    10. {
    11. cout<<"Base::f(float)"< }
    12. voidg(floatx)
    13. {
    14. cout<<"Base::g(float)"< }
    15. voidh(floatx)
    16. {
    17. cout<<"Base::h(float)"< }
    18. };
    19. classDerived:publicBase
    20. {
    21. public:
    22. virtualvoidf(floatx)
    23. {
    24. cout<<"Derived::f(float)"< }
    25. voidg(intx)
    26. {
    27. cout<<"Derived::g(int)"< }
    28. voidh(floatx)
    29. {
    30. cout<<"Derived::h(float)"< }
    31. };
    32. intmain(void)
    33. {
    34. Derivedd;
    35. Base*pb=&d;
    36. Derived*pd=&d;
    37. //Good:behaviordependssolelyontypeoftheobject
    38. pb->f(3.14f);//Derived::f(float)3.14
    39. pd->f(3.14f);//Derived::f(float)3.14
    40.  
    41. //Bad:behaviordependsontypeofthepointer
    42. pb->g(3.14f);//Base::g(float)3.14
    43. pd->g(3.14f);//Derived::g(int)3
    44.  
    45. //Bad:behaviordependsontypeofthepointer
    46. pb->h(3.14f);//Base::h(float)3.14
    47. pd->h(3.14f);//Derived::h(float)3.14
    48. return0;
    49. } 令人迷惑的隱藏規則
        本來僅僅區別重載與覆蓋並不算困難，但是C++的隱藏規則使問題復雜性陡然增加。
        這裡“隱藏”是指派生類的函數屏蔽了與其同名的基類函數，規則如下：
        （1）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual
        關鍵字，基類的函數將被隱藏（注意別與重載混淆）。
        （2）如果派生類的函數與基類的函數同名，並且參數也相同，但是基類函數沒有virtual
        關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）。
        上面的程序中：
        （1）函數Derived::f(float)覆蓋了Base::f(float)。
        （2）函數Derived::g(int)隱藏了Base::g(float)，而不是重載。
        （3）函數Derived::h(float)隱藏了Base::h(float)，而不是覆蓋。
        
        C++純虛函數
        一、定義
        純虛函數是在基類中聲明的虛函數，它在基類中沒有定義，但要求任何派生類都要定義自己的實現方法。在基類中實現純虛函數的方法是在函數原型後加“=0”
        virtual void funtion()=0
        二、引入原因
        1、為了方便使用多態特性，我們常常需要在基類中定義虛擬函數。
        2、在很多情況下，基類本身生成對象是不合情理的。例如，動物作為一個基類可以派生出老虎、孔雀等子類，但動物本身生成對象明顯不合常理。
        為了解決上述問題，引入了純虛函數的概念，將函數定義為純虛函數（方法：virtual ReturnType Function()= 0;），則編譯器要求在派生類中必須予以重寫以實現多態性。同時含有純虛擬函數的類稱為抽象類，它不能生成對象。這樣就很好地解決了上述兩個問題。
        三、相似概念
        1、多態性
        指相同對象收到不同消息或不同對象收到相同消息時產生不同的實現動作。C++支持兩種多態性：編譯時多態性，運行時多態性。
        a、編譯時多態性：通過重載函數實現
        b、運行時多態性：通過虛函數實現。
        2、虛函數
        虛函數是在基類中被聲明為virtual，並在派生類中重新定義的成員函數，可實現成員函數的動態覆蓋（Override）
        3、抽象類
        包含純虛函數的類稱為抽象類。由於抽象類包含了沒有定義的純虛函數，所以不能定義抽象類的對象。