浅谈c++多态性

        C++编程语言是一款应用广泛，支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识，以方便大家在学习过程中对此能够有一个充分的掌握。
　　多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphisn)，字面意思多种形状。
　　C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。（这里我觉得要补充，重写的话可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作是体现了C++多态性）而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。
　　多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。
　　那么多态的作用是什么呢，封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。

　　最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。

笔试题目：

[cpp] view plain copy print ?

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

#include<iostream>  
using namespace std;  
  
class A  
{  
public:  
    void foo()  
    {  
        printf("1\n");  
    }  
    virtual void fun()  
    {  
        printf("2\n");  
    }  
};  
class B : public A  
{  
public:  
    void foo()  
    {  
        printf("3\n");  
    }  
    void fun()  
    {  
        printf("4\n");  
    }  
};  
int main(void)  
{  
    A a;  
    B b;  
    A *p = &a;  
    p->foo();  
    p->fun();  
    p = &b;  
    p->foo();  
    p->fun();  
    return 0;  
}  

[cpp] view plain copy print ?

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

//小结：1、有virtual才可能发生多态现象  
// 2、不发生多态（无virtual）调用就按原类型调用  
#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;   //隐藏  
    }  
};  
int 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   
  
    // Bad : behavior depends on type of the pointer  
    pb->h(3.14f);   // Base::h(float) 3.14  
    pd->h(3.14f);   // Derived::h(float) 3.14  
    return 0;  
}  

二、虚函数和纯虚函数的区别

首先：强调一个概念

假设我们有下面的类层次：

[cpp] view plain copy print ?

1. class A  
2. {  
3. public:  
4.     virtual void foo()  
5.     {  
6.         cout<<"A::foo() is called"<<endl;  
7.     }  
8. };  
9. class B:public A  
10. {  
11. public:  
12.     void foo()  
13.     {  
14.         cout<<"B::foo() is called"<<endl;  
15.     }  
16. };  
17. int main(void)  
18. {  
19.     A *a = new B();  
20.     a->foo();   // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!  
21.     return 0;  
22. }  

class A
{
public:
    virtual void foo()
    {
        cout<<"A::foo() is called"<<endl;
    }
};
class B:public A
{
public:
    void foo()
    {
        cout<<"B::foo() is called"<<endl;
    }
};
int main(void)
{
    A *a = new B();
    a->foo();   // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
    return 0;
}