C++多态性和继承性

        这篇文章是6年前的，从自己的QQ（632846506）日志中移过来的。https://user.qzone.qq.com/632846506/infocenter。

       前段时间有人突然问我C++多态性的理论知识，一下子把我问蒙了，用c++近十年，让我一下子回答多态性的理论。我答不上来，只是简单的回答了下“多态性主要用在函数接口上，主要是虚函数和纯虚函数的使用，基类中的函数可以在不同子类中有不同的实现形式”。汗~~~~，用了近十年却讲不出具体的理论知识来，汗颜啦~，这里补一下理论知识。

        C++的多态性：指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，运行时多态性。其中： 
         a、编译时多态性：通过重载函数实现； 
         b、运行时多态性：通过虚函数实现。     

       C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数(在子类里重新定义父类的相关函数）。其多态性可以简单地概括为“一个接口（基类），多种方法（子类）”，或者说虚函数在基类中只定义不实现，在子类中定义同一函数且实现。

       C++里有重写(覆盖)和重载两个概念：

       重写发生在继承关系中的子类中，当子类要修改从父类中继承到的函数时，就可以在子类中声明一个与父类同名、同参、同返回值类型的函数，覆盖又叫重写。重写有重写成员函数和重写虚函数，重写虚函数的才是体现了C++多态性；

        重载则是允许有多个同名的函数，但这些函数要么满足参数列表不同，要么满足参数个数不同，要么满足参数类型不同，或者两者都不同。所以重载并不涉及继承的问题。由于重载的参数不同，在调用的时候已经明确了要使用哪一个函数操作和返回值，因此重载是属于非运行时的，也就是运行之前就已经明确的。

       多态的优势：其封装可以使得代码模块化，继承可以扩展已存在的代码，目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。

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

      简单说明下纯虚函数：纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”，如virtual void funtion()=0  。

     为什么引入纯虚函数：
      一是为了方便使用多态特性，如常常根据需要在基类中定义虚拟函数；

      二是在很多情况下，基类本身生成对象是不合情理的。
      将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。

其他相关说明：
      虚函数：是在基类中被声明为virtual，并在派生类中重新定义的成员函数，可实现成员函数的动态覆盖（Override）
      抽象类：包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。

举例说明下：

1. class A  
2. {  
3. public:  
4.     void fun1()  
5.     {  
6.         cout<<"A0"<<endl;  
7.     }  
8.     virtual void fun2()  
9.     {  
10.         out<<"A1"<<endl;  
11.     }  
12. };  
13. class B : public A  
14. {  
15. public:  
16.     void fun1()  
17.     {  
18.         out<<"B0"<<endl; 
19.     }  
20.     void fun2()  
21.     {  
22.         out<<"B1"<<endl;  
23.     }  
24. };  
25. void main(void)  
26. {  
27.     A a;  
28.     B b;  
29.     A *p = &a;  
30.     p->fun1();  
31.     p->fun2();  
32.     p = &b;  
33.     p->fun1();  
34.     p->fun2();    
35. }  

      第一个p->fun1()和p->fun2()，输出结果就是A0、A1，其本身是父类指针，指向的又是父类对象，调用的都是父类本身的函数。
 　  第二个输出结果就是A0、B1。p->fun1()是父类指针指向子类对象，体现了C++多态的用法，p->fun1()，由于指针是个父类指针，指向是一个固定偏移量的函数，因此指向的就是父类fun1()函数的代码，因此输出的结果还是1。p->fun2()指针是父类指针，指向的fun2是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun2()并不是直接调用函数，而是通过虚函数列表找到相应的函数的地址，因此根据指向的对象不同，函数地址也将不同，这里将找到对应的子类的fun()函数的地址，因此输出的结果也会是子类的结果4。
　　那下列语句输出什么呢？
       B *ptr = (B *)&a;  

       ptr->fun1();  

       ptr->fun2();
　　这是一个用子类的指针去指向一个强制转换为子类地址的父类对象。结果，这两句调用的输出结果是3，2。
　　由于B是子类指针，虽然被赋予了父类对象地址，但是ptr->fun1()在调用的时候，由于地址偏移量固定，偏移量是子类对象的偏移量，于是即使在指向了一个父类对象的情况下，还是调用到了子类的函数，尽管有时可能从始到终都没有子类对象的实例化出现。
　　而ptr->fun2()的调用，还是因为C++多态性的原因，由于指向的是一个父类对象，通过虚函数列表的引用，找到了父类中fun()函数的地址，因此调用了父类的函数。由此可见多态性的强大，可以适应各种变化，不论指针是父类的还是子类的，都能找到正确的实现方法。

     

      继承性就不介绍了，顾名思义，子类继承父类/子类继承基类。