C++多态

我不是女神ヾ 2021-11-27 06:52 349阅读 0赞

## C++多态 ##

**多态概念**

字面意思，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：假如你要去看电影，有的影院也许有这样的规定，如果你是成年人，那么就是全票，如果你是学生，那么就是半价票，如果你是一个小孩子，那么你就不需要票，免费。这就是很典型的一个例子，针对不同的对象，你去做这件事发生的结果是不一样的。

**多态的发生条件**

1.  必须通过基类的指针或者引用调用虚函数
2.  要有虚函数的重写（虚函数：即被virtual修饰的类成员函数称为虚函数。）

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

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

**虚函数重写的两个特例**

1.  协变(基类与派生类虚函数返回值类型不同)  
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

class A{ };
    class B : public A { };
    class Person { 
    public:
     virtual A* f() { return new A;}
    };
    class Student : public Person { 
    public:
     virtual B* f() { return new B;}
    };

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

class Person { 
    public:
     virtual ~Person() { cout << "~Person()" << endl;}
    };
    class Student : public Person { 
    public:
     virtual ~Student() {  cout << "~Student()" << endl; }
    };

**C++11 override 和 final**  
从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

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

class A
    { 
    public:
     virtual void print() final { }
    };
    class B :public A
    { 
    public:
     virtual void print() { cout << "print" << endl;}
    };

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

class A{ 
    public:
     virtual void print(){ }
    };
    class B :public A { 
    public:
     virtual void print() override { cout << "print" << endl;}
    };

**重载、重写、重定义**

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

## 抽象类 ##

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

class A{ 
    public:
     virtual void print() = 0;
    };
    class B :public A { 
    public:
     virtual void print() override { cout << "print" << endl;}
    };

## 多态的原理 ##

**虚函数表**

class A
    { 
    public:
     virtual void Func1()
     { 
     cout << "Func1()" << endl;
     }
    private:
     int _a = 1;
    };
    
    //sizeof(A) = 8

通过观察测试我们发现b对象是8bytes，除了\_a成员，还多一个\_\_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，  
虚函数表也简称虚表。  
假如我们再改变一些代码，如下所示：

class A
    { 
    public:
     virtual void Func1()
     { 
     cout << "A::Func1()" << endl;
     }
     virtual void Func2()
     { 
     cout << "A::Func2()" << endl;
     }
     void Func3()
     { 
     cout << "A::Func3()" << endl;
     }
    private:
     int _b = 1;
    };
    class B : public A
    { 
    public:
     virtual void Func1()
     { 
     cout << "B::Func1()" << endl;
     }
    private:
     int _d = 2;
    };

通过观察和测试，我们发现了以下几点问题：

1.  派生类对象中也有一个虚表指针，对象由两部分构成，一部分是父类继承下来的成员及虚表指针,另一部分是自己的成员。
2.  基类对象和派生类对象虚表是不一样的，这里我们发现Func1完成了重写，所以派生类对象的虚表中存的是重写的B::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。
3.  另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
4.  虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
5.  派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

**多态的原理**  
在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。

**静态绑定与动态绑定**

1.  静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错。
2.  动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。当我们将函数声明为virtual 时，编译器不会在编译时就确定对象要调用的函数的地址，而是在运行时再去确定要调用的函数的地址，这就是晚绑定，也叫做动态绑定。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNTAzMzE1_size_16_color_FFFFFF_t_70 1]  
**关于多态的一些其它知识点**

1.  inline函数可以是虚函数吗？答：不能，因为inline函数没有地址，无法把地址放到虚函数表中。
2.  静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
3.  构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
4.  析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。
5.  对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
6.  虚函数表是在什么阶段生成的，存在哪的？答：虚函数是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNTAzMzE1_size_16_color_FFFFFF_t_70]: /images/20211126/30bc284eebaa4b60b8e26f1ef6f95a92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNTAzMzE1_size_16_color_FFFFFF_t_70 1]: /images/20211126/0480b34e83c7422695e835a67c1c9a19.png