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. }  

（3）函式Derived::h(float)隱藏了Base::h(float)，而不是覆蓋。

me：過載是發生在同作用域中，見C++primer第四版，p500

-----------------------------------下面是一個覆蓋與隱藏的例子-------------------

#include<iostream>
class a{
        public:
        virtual void print(){
                std::cout<<"NULL print in a"<<std::endl;
        }
        virtual void print(int){
                std::cout<<"int print in a"<<std::endl;
        }
};
class b:public a{
public:
        virtual void print(){//can hide print ,print(int) in a
                std::cout<<"NULL print in b"<<std::endl;
        }
};
class c:public b{
public:
        virtual void print(int){//can hide print in b,a
                std::cout<<"int print in c"<<std::endl;
        }
};
int main(){
        b b1;
        b1.print();
        //b1.print(1);//compile error,hide
        c c1;
        c1.print(1);
        //c1.print();//compile error,hide

        //虛擬函式被隱藏，但是還是可以通過指標訪問到，如果不是虛擬函式，當然通過指標也不能
        a*ap=new c;
        ap->print(1);//int print in c
}
~ 

過載可以是函式的返回值型別不同，但是不能只是函式返回值型別不同；虛擬函式實現多型，子類中的虛擬函式的返回型別可以為父類中相應虛擬函式的返回型別可以不完全相同， 如返回引用或指標，子類的返回型別可以是父類的返回型別的子類，但函式引數型別必須完全相同，否則會出現上面程式碼情況。

#include <iostream>
class test{};
class test1:public test{};
test t;
test1 t1;
#include <iostream>
class test{};
class test1:public test{};
test t;
test1 t1;
class base{
public:
        virtual test& print(test1*){
                std::cout<<"print in base"<<std::endl;
                return t;
        }

};
class derived:public base{
public:
        test1& print (test1*){
                std::cout<<"print in derived"<<std::endl;
                return t1;
        }
};
int main(){
        base*b=new(std::nothrow) derived;
        b->print(new test1);//base :: print
        delete b;
        b=new (std::nothrow)base;
        b->print(new test1);//derived::print
        delete b;
}