【C++】多态知识点大总结

系统管理员 2022-12-28 06:22 172阅读 0赞

### 文章目录 ###

*  一、多态的概念
 *  二、多态的定义和实现
 *   *  2.1 多态的构成条件
     *  2.2 虚函数
     *  2.3 虚函数的重写
     *  2.4 C++11 override 和 final
     *  2.5 重载、覆盖(重写)、隐藏(重定义)的对比
 *  三、抽象类
 *   *  3.1 概念
     *  3.2 接口继承和实现继承
 *  四、多态的原理
 *   *  4.1 虚表函数
     *  4.2 动态绑定与静态绑定
 *  五、单继承和多继承关系中的虚表函数
 *   *  5.1 单继承中的虚表函数
     *  5.2 多继承中的虚函数表

# 一、多态的概念 #

**本篇文章代码及解释都是在vs2013下的x86程序中，涉及的指针都是4bytes。**

**多态的概念**：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同  
的状态。举个例子：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70]

# 二、多态的定义和实现 #

## 2.1 多态的构成条件 ##

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。那么在继承中要构成多态还有**两个条件**：

1.  必须通过基类的指针或者引用调用虚函数；
2.  被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 1]

在多态条件满足的前提下，**程序编译**时，编译器无法知道p到底引用的是哪个类的对象，因此不会去确定p.BuyTicket()该函数的行为（具体调用哪个类的虚函数）；只有在**程序运行**起来之后，才能确定p到底指向的是哪个类的对象。

## 2.2 虚函数 ##

**虚函数**：即被virtual修饰的类成员函数称为虚函数。

class Person
    {
        
    public:
    	virtual void BuyTicket()
    	{
        
    		cout << "全价票" << endl;
    	}
    };

## 2.3 虚函数的重写 ##

**虚函数的重写(覆盖)**：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class Person
    {
        
    public:
    	virtual void BuyTicket()
    	{
        
    		cout << "全价票" << endl;
    	}
    };
    class Student : public Person
    {
        
    public:
    	virtual void BuyTicket()
    	{
        
    		cout << "半价票" << endl;
    	}
    };

**虚函数重写的两个例外：**

1.  协变(基类与派生类虚函数返回值类型不同).派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
2.  析构函数的重写(基类与派生类析构函数的名字不同)  
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

## 2.4 C++11 override 和 final ##

1.  final：修饰虚函数，表示该虚函数不能再被继承

class Car
    {
        
    public:
    	virtual void Drive() final
    	{
        }
    };
    class Benz : public Car
    {
        
    public:
    	virtual void Drive()
    	{
        
    		cout << "Benz-舒适" << endl;
    	}
    };

1.  override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car
    {
        
    public:
    	virtual void Drive() 
    	{
        }
    };
    class Benz : public Car
    {
        
    public:
    	virtual void Drive()override
    	{
        
    		cout << "Benz-舒适" << endl;
    	}
    };

## 2.5 重载、覆盖(重写)、隐藏(重定义)的对比 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 2]

# 三、抽象类 #

## 3.1 概念 ##

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Car
    {
        
    public:
        virtual void Drive() = 0
    };

## 3.2 接口继承和实现继承 ##

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

# 四、多态的原理 #

## 4.1 虚表函数 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 3]  
通过观察，我们发现b对象时8字节，除了\_b成员，还多了一个 \_vfptr放在对象的前面（注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。**我们进一步观察**：

//派生类重写了f1(),f3(),新增加了f4(),f5()
    class Base
    {
        
    public:
    	virtual void f1()
    	{
        
    		cout << "Base::f1()" << endl;
    	}
    
    	virtual void f2()
    	{
        
    		cout << "Base::f2()" << endl;
    	}
    
    	virtual void f3()
    	{
        
    		cout << "Base::f3()" << endl;
    	}
    	int _b;
    };
    
    class Derived : public Base
    {
        
    public:
    	virtual void f4()
    	{
        
    		cout << "Derived::f4()" << endl;
    	}
    
    	virtual void f1()
    	{
        
    		cout << "Derived::f1()" << endl;
    	}
    
    	virtual void f3()
    	{
        
    		cout << "Derived::f3()" << endl;
    	}
    
    	virtual void f5()
    	{
        
    		cout << "Derived::f5()" << endl;
    	}
    	int _d;
    
    };

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 4]  
**总结如下**：

1.  派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，另一部分是自己的成员。
2.  . 基类b对象和派生类d对象虚表是不一样的。f1和f3重写，f2从基类中继承，f4和f5新增。（如果基类中有函数不是虚函数，虽然也会被继承下来，但是不会放进虚表中）。
3.  虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
4.  . 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基  
    类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
5.  虚表存的是虚函数指针，虚函数和普通函数一样的，都是存在代码段的，对象中存的是虚表指针，虚表在vs下存在代码段。

## 4.2 动态绑定与静态绑定 ##

1.  静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
2.  动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用  
    具体的函数，也称为动态多态。

# 五、单继承和多继承关系中的虚表函数 #

## 5.1 单继承中的虚表函数 ##

在4.1中的例子已经详细说明，可参考。

## 5.2 多继承中的虚函数表 ##

class Base1 
    {
        
    public:
    	virtual void func1() 
    	{
        
    		cout <<"Base1::func1" << endl;
    	}
    	virtual void func2() 
    	{
        
    		cout <<"Base1::func2" << endl;
    	}
    private:
    	int b1;
    };
    class Base2 
    {
        
    public:
    	virtual void func1()
    	{
        
    		cout <<"Base2::func1" << endl;
    	}
    	virtual void func2() 
    	{
        
    		cout << "Base2::func2" << endl;
    	}
    private:
    	int b2;
    };
    class Derive : public Base1, public Base2 
    {
        
    public:
    	virtual void func1() 
    	{
        
    		cout << "Derive::func1" << endl;
    	}
    	virtual void func3() 
    	{
        
    		cout << "Derive::func3" << endl;
    	}
    private:
    	int d1;
    };

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 5]  
观察上图可知：**多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70]: /images/20221120/e0b1786fa68543c7b4c81aa9d3653a82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 1]: /images/20221120/83964228f4984764ba48330dabad120f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201215094639115.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020121510061730.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020121510360754.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201215111948213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9fbGVpbGVp,size_16,color_FFFFFF,t_70