C++三大特性之多态

朴灿烈づ我的快乐病毒、 2022-05-23 04:06 222阅读 0赞

原文地址：  
[http://huqunxing.site/2016/09/08/C++%20%E4%B8%89%E5%A4%A7%E7%89%B9%E6%80%A7%E4%B9%8B%E5%A4%9A%E6%80%81/][http_huqunxing.site_2016_09_08_C_20_E4_B8_89_E5_A4_A7_E7_89_B9_E6_80_A7_E4_B9_8B_E5_A4_9A_E6_80_81]

C++ 的三大特性，封装，继承，多态。封装可以使得代码模块化，继承可以扩展已存在的代码，而多态的目的则是为了接口重用。本篇博客主要介绍C++中多态的相关概念及使用方法。

## 概念 ##

### 多态（Polymorphisn） ###

> 多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说：允许将子类类型的指针赋值给父类类型的指针（一个接口，多种方法）。  
> C++ 支持两种多态性：编译时多态性，运行时多态性。  
> a、编译时多态性（静态多态）：通过重载函数实现  
> b、运行时多态性（动态多态）：通过虚函数实现。

### 多态的作用 ###

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

### 多态的用法 ###

**运行时多态：**

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

**非运行时多态：**

> 通过函数重载实现

**简而言之：**

1.  有virtual才可能发生动态多态现象
2.  （无virtual）调用就按原类型调用

### 令人迷惑的隐藏规则 ###

**隐藏**是指派生类的函数屏蔽了与其**同名**的基类函数，规则如下：

*  如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆，重载是在同一个类中，而隐藏涉及派生类与基类）。
 *  如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆，覆盖有virtual关键字）。

### C++虚函数 ###

**虚函数：** 就是允许被其子类重新定义的成员函数，子类重新定义父类虚函数的做法，可实现成员函数的动态覆盖（Override）。

**纯虚函数：** 是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”

<table> 
 <tbody> 
  <tr> 
   <td><pre>       
        
     <div>
      
         
        1
       
        
     </div></pre></td> 
   <td><pre>       
        
     <div>
        
         
      <span><span>virtual</span> <span>void</span> <span>funtion</span><span>()</span></span>=
        
         
      <span>0</span>
       
        
     </div></pre></td> 
  </tr> 
 </tbody> 
</table>

**抽象类：** 包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能进行实例化。

**纯虚函数的作用：**

1.  为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。
2.  在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。  
    为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：`virtual ReturnType Function()= 0;`），则编译器要求在派生类中**必须予以重写**以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。

示例代码：

<table> 
 <tbody> 
  <tr> 
   <td><pre>       
        
     <div>
      
         
        1
       
        
     </div>
       
        
     <div>
      
         
        2
       
        
     </div>
       
        
     <div>
      
         
        3
       
        
     </div>
       
        
     <div>
      
         
        4
       
        
     </div>
       
        
     <div>
      
         
        5
       
        
     </div>
       
        
     <div>
      
         
        6
       
        
     </div>
       
        
     <div>
      
         
        7
       
        
     </div>
       
        
     <div>
      
         
        8
       
        
     </div>
       
        
     <div>
      
         
        9
       
        
     </div>
       
        
     <div>
      
         
        10
       
        
     </div>
       
        
     <div>
      
         
        11
       
        
     </div>
       
        
     <div>
      
         
        12
       
        
     </div>
       
        
     <div>
      
         
        13
       
        
     </div>
       
        
     <div>
      
         
        14
       
        
     </div>
       
        
     <div>
      
         
        15
       
        
     </div>
       
        
     <div>
      
         
        16
       
        
     </div>
       
        
     <div>
      
         
        17
       
        
     </div>
       
        
     <div>
      
         
        18
       
        
     </div>
       
        
     <div>
      
         
        19
       
        
     </div>
       
        
     <div>
      
         
        20
       
        
     </div>
       
        
     <div>
      
         
        21
       
        
     </div>
       
        
     <div>
      
         
        22
       
        
     </div>
       
        
     <div>
      
         
        23
       
        
     </div>
       
        
     <div>
      
         
        24
       
        
     </div>
       
        
     <div>
      
         
        25
       
        
     </div>
       
        
     <div>
      
         
        26
       
        
     </div>
       
        
     <div>
      
         
        27
       
        
     </div>
       
        
     <div>
      
         
        28
       
        
     </div>
       
        
     <div>
      
         
        29
       
        
     </div>
       
        
     <div>
      
         
        30
       
        
     </div>
       
        
     <div>
      
         
        31
       
        
     </div>
       
        
     <div>
      
         
        32
       
        
     </div>
       
        
     <div>
      
         
        33
       
        
     </div>
       
        
     <div>
      
         
        34
       
        
     </div>
       
        
     <div>
      
         
        35
       
        
     </div>
       
        
     <div>
      
         
        36
       
        
     </div>
       
        
     <div>
      
         
        37
       
        
     </div>
       
        
     <div>
      
         
        38
       
        
     </div>
       
        
     <div>
      
         
        39
       
        
     </div>
       
        
     <div>
      
         
        40
       
        
     </div>
       
        
     <div>
      
         
        41
       
        
     </div>
       
        
     <div>
      
         
        42
       
        
     </div>
       
        
     <div>
      
         
        43
       
        
     </div>
       
        
     <div>
      
         
        44
       
        
     </div>
       
        
     <div>
      
         
        45
       
        
     </div>
       
        
     <div>
      
         
        46
       
        
     </div>
       
        
     <div>
      
         
        47
       
        
     </div>
       
        
     <div>
      
         
        48
       
        
     </div>
       
        
     <div>
      
         
        49
       
        
     </div>
       
        
     <div>
      
         
        50
       
        
     </div>
       
        
     <div>
      
         
        51
       
        
     </div>
       
        
     <div>
      
         
        52
       
        
     </div>
       
        
     <div>
      
         
        53
       
        
     </div>
       
        
     <div>
      
         
        54
       
        
     </div>
       
        
     <div>
      
         
        55
       
        
     </div>
       
        
     <div>
      
         
        56
       
        
     </div>
       
        
     <div>
      
         
        57
       
        
     </div></pre></td> 
   <td><pre>       
        
     <div>
        
         
      <span>#<span>include</span><span>&lt;iostream&gt;</span></span>
       
        
     </div>
       
        
     <div>
        
         
      <span>using</span> 
        
         
      <span>namespace</span> 
        
         
      <span>std</span>;
       
        
     </div>
       
        
     <div></div>
       
        
     <div>
        
         
      <span>//基类对象</span>
       
        
     </div>
       
        
     <div>
        
         
      <span>class</span> Base
       
        
     </div>
       
        
     <div>
      
         
        {
       
        
     </div>
       
        
     <div>
        
         
      <span>public</span>:
       
        
     </div>
       
        
     <div>    
        
         
      <span>//有virtual关键字，运行时多态</span>
       
        
     </div>
       
        
     <div>    
        
         
      <span><span>virtual</span> <span>void</span> <span>f</span><span>(<span>float</span> x)</span></span>
       
        
     </div>
       
        
     <div>
      
         
         {
       
        
     </div>
       
        
     <div>       
        
         
      <span>cout</span>&lt;&lt;
        
         
      <span>"Base::f(float)"</span>&lt;&lt; x &lt;&lt;
        
         
      <span>endl</span>;
       
        
     </div>
       
        
     <div>
      
         
            }
       
        
     </div>
       
        
     <div>    
        
         
      <span>//无viratul关键字，不会发生运行时多态</span>
       
        
     </div>
       
        
     <div>   
        
         
      <span><span>void</span> <span>g</span><span>(<span>float</span> x)</span></span>
       
        
     </div>
       
        
     <div>
      
         
          {
       
        
     </div>
       
        
     <div>       
        
         
      <span>cout</span>&lt;&lt;
        
         
      <span>"Base::g(float)"</span>&lt;&lt; x &lt;&lt;
        
         
      <span>endl</span>;
       
        
     </div>
       
        
     <div>
      
         
            }
       
        
     </div>
       
        
     <div>   
        
         
      <span><span>void</span> <span>h</span><span>(<span>float</span> x)</span></span>
       
        
     </div>
       
        
     <div>
      
         
          {
       
        
     </div>
       
        
     <div>       
        
         
      <span>cout</span>&lt;&lt;
        
         
      <span>"Base::h(float)"</span>&lt;&lt; x &lt;&lt;
        
         
      <span>endl</span>;
       
        
     </div>
       
        
     <div>
      
         
            }
       
        
     </div>
       
        
     <div>
      
         
        };
       
        
     </div>
       
        
     <div>
        
         
      <span>class</span> Derived : 
        
         
      <span>public</span> Base
       
        
     </div>
       
        
     <div>
      
         
        {
       
        
     </div>
       
        
     <div>
        
         
      <span>public</span>:
       
        
     </div>
       
        
     <div>   
        
         
      <span><span>virtual</span> <span>void</span> <span>f</span><span>(<span>float</span> x)</span></span>
       
        
     </div>
       
        
     <div>
      
         
         {
       
        
     </div>
       
        
     <div>       
        
         
      <span>cout</span>&lt;&lt;
        
         
      <span>"Derived::f(float)"</span>&lt;&lt; x &lt;&lt;
        
         
      <span>endl</span>;   
        
         
      <span>//多态、覆盖</span>
       
        
     </div>
       
        
     <div>
      
         
          }
       
        
     </div>
       
        
     <div>    
        
         
      <span>//子类与父类的函数同名，无virtual关键字，则为隐藏</span>
       
        
     </div>
       
        
     <div> 
        
         
      <span><span>void</span> <span>g</span><span>(<span>int</span> x)</span></span>
       
        
     </div>
       
        
     <div>
      
         
            {
       
        
     </div>
       
        
     <div>       
        
         
      <span>cout</span>&lt;&lt;
        
         
      <span>"Derived::g(int)"</span>&lt;&lt; x &lt;&lt;
        
         
      <span>endl</span>;     
        
         
      <span>//隐藏</span>
       
        
     </div>
       
        
     <div>
      
         
         }
       
        
     </div>
       
        
     <div>   
        
         
      <span><span>void</span> <span>h</span><span>(<span>float</span> x)</span></span>
       
        
     </div>
       
        
     <div>
      
         
          {
       
        
     </div>
       
        
     <div>       
        
         
      <span>cout</span>&lt;&lt;
        
         
      <span>"Derived::h(float)"</span>&lt;&lt; x &lt;&lt;
        
         
      <span>endl</span>;   
        
         
      <span>//隐藏</span>
       
        
     </div>
       
        
     <div>
      
         
         }
       
        
     </div>
       
        
     <div>
      
         
        };
       
        
     </div>
       
        
     <div>
        
         
      <span><span>int</span> <span>main</span><span>(<span>void</span>)</span></span>
       
        
     </div>
       
        
     <div>
      
         
        {
       
        
     </div>
       
        
     <div>
      
         
           Derived d;  
        
         
      <span>//子类</span>
       
        
     </div>
       
        
     <div>
      
         
           Base *pb = &amp;d;  
        
         
      <span>//基类指针指向子类</span>
       
        
     </div>
       
        
     <div>
      
         
         Derived *pd = &amp;d;   
        
         
      <span>//子类指针指向自己</span>
       
        
     </div>
       
        
     <div> 
        
         
      <span>// Good : behavior depends solely on type of the object</span>
       
        
     </div>
       
        
     <div>
      
         
            pb-&gt;f(
        
         
      <span>3.14f</span>);   
        
         
      <span>// Derived::f(float) 3.14  调用子类，多态</span>
       
        
     </div>
       
        
     <div>
      
         
          pd-&gt;f(
        
         
      <span>3.14f</span>);   
        
         
      <span>// Derived::f(float) 3.14  调用子类</span>
       
        
     </div>
       
        
     <div></div>
       
        
     <div> 
        
         
      <span>// Bad : behavior depends on type of the pointer</span>
       
        
     </div>
       
        
     <div>
      
         
           pb-&gt;g(
        
         
      <span>3.14f</span>);   
        
         
      <span>// Base::g(float)  3.14    无多态，调用自己的</span>
       
        
     </div>
       
        
     <div>
      
         
            pd-&gt;g(
        
         
      <span>3.14f</span>);   
        
         
      <span>// Derived::g(int) 3   无多态，调用自己的</span>
       
        
     </div>
       
        
     <div></div>
       
        
     <div>    
        
         
      <span>// Bad : behavior depends on type of the pointer</span>
       
        
     </div>
       
        
     <div>
      
         
           pb-&gt;h(
        
         
      <span>3.14f</span>);   
        
         
      <span>// Base::h(float) 3.14 无多态，调用自己的</span>
       
        
     </div>
       
        
     <div>
      
         
            pd-&gt;h(
        
         
      <span>3.14f</span>);   
        
         
      <span>// Derived::h(float) 3.14  无多态，调用自己的</span>
       
        
     </div>
       
        
     <div>    
        
         
      <span>return</span> 
        
         
      <span>0</span>;
       
        
     </div>
       
        
     <div>
      
         
        }
       
        
     </div></pre></td> 
  </tr> 
 </tbody> 
</table>

[http_huqunxing.site_2016_09_08_C_20_E4_B8_89_E5_A4_A7_E7_89_B9_E6_80_A7_E4_B9_8B_E5_A4_9A_E6_80_81]: http://huqunxing.site/2016/09/08/C++%20%E4%B8%89%E5%A4%A7%E7%89%B9%E6%80%A7%E4%B9%8B%E5%A4%9A%E6%80%81/