一文掌握 C++ 多态：原理、用法、坑点

╮(๑•́ ₃•̀๑)╭博主的博客主页------>Cinema KI

( ´◔ ‸◔`) 博主的gitee主页------>IIirving

文章目录

👀前言
🔉一、多态的概念
🔇二、多态的定义及实现
- 2.1多态的构成条件
⌚三、虚函数
💡四、重载/重写/隐藏的对比
☔五、纯虚函数和抽象类
⚡六、多态的原理
🎓七、总结

👀前言

本篇文章大家将跟着我一起学习多态章节。本章是最难的一个部分了，建议大家先学一遍多态的基本知识，再跟着我进行复习，效果会好很多。

提示：以下是本篇文章正文内容，下面案例可供参考

🔉一、多态的概念

多态(polymorphism)的概念：通俗地说，就是多种形态 。多态分别编译时多态（静态多态）和运行时多态（动态多态），这里我们重点讲运行时多态，编译器是多态（静态多态）和运行时多态（动态多态）。编译时多态（静态多态）主要就是我们前面讲的函数重载和函数模板，他们传不同类型的参数就可以调用不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的，我们把编译时一般归为静态，运行时归为动态。

运行时多态，具体点就是去完成某个行为（函数），可以传不同的对象就会完成不同的行为 ，就达到多种形态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，时优惠买票；军人买票时，是优先买票。再比如，同样是动物叫的一个行为，传猫对象过去，就是"喵~"，传狗对象过去，就是"汪汪"。

🔇二、多态的定义及实现

2.1多态的构成条件

多态是一个继承关系下的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象优惠买票。

★重点：构成多态的另外两个重要条件
· 必须是基类的指针或者引用调用虚函数
· 被调用的函数必须是虚函数，并且完成了虚函数重写/覆盖。

说明：要实现多态效果，第一必须是基类的指针或引用，因为只有基类的指针或引用才能既指向基类对象又指向派生类对象 ；第二派生类必须对基类的虚函数完成重写/覆盖 ，重写或者覆盖了，基类和派生类之间才能有不同的函数，多态的不同形态效果才能达到。

⌚三、虚函数

类成员函数前面加virtual 修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加virtual修饰。
代码示例，如下

cpp 复制代码

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

3.1虚函数的重写/覆盖

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

注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写（因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性），但是这种写法不是很规范，不建议这样使用，不过在考试选择题中，经常会故意埋这个坑，让你判断是否构成多态。

代码示例，如下

cpp 复制代码

class Person
{
public:
     virtual void Buyticket(){cout<<"买票-全价"<<endl;}
};
class Student
{
public:
     virtual void Buyticket(){cout<<"买票-半价"<<endl;}
};
void Func(Person* ptr)
{
    ptr->Buyticket();
}
int main()
{
    Person ps;
    Student s;
    Func(&ps);
    Func(&s);
    return 0;
}

3.2虚函数重写的一些问题

· 协变（了解）
派生类重写基类虚函数时，与基类虚函数返回值类型不同 。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。协变的实际意义并不大，所以我们了解一下即可。
代码示例，如下

cpp 复制代码

class A {};
class B : public A {};

class Person{
public:
     virtual A* Buyticket()
     {
         cout<<"买票-全价"<<endl;
         return nullptr;
     }
};
//
class Student : public Person{
public:
     virtual B* Buyticket()
     {
         cout<<"买票-打折"<<endl;
     }
};

· 重点：析构函数的重写

基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理称destructor,所以基类的析构函数加了virtual修饰，派生类的析构函数就构成重写。

下面的代码我们可以看到，如果~A()，不加virtual，那么delete p2时只调用A的析构函数，没有调用B的析构函数，就会导致内存泄漏的问题，因为B中有资源需要清理。

注意：面试常考

cpp 复制代码

class A
{
public:
     virtual ~A()
     {
       cout<<"~A()"<<endl;
     }
};
//
class B:public A
{
public:
     ~B()
     {
        cout<<"~B()"<<_p<<endl;
        delete _p;
     }
     int* _p = new int[10];
};
int main()
{
    A* p1 = new A;
    A* p2 = new B;
    delete p1;
    delete p2;
}

如果这里virtual ~A()，前面不加关键字virtual的话，那么就不构成多态。那么p1与p2这两个A*类型的指针都调用的本类型的析构，那么p2指向的派生类那块空间就没有得到释放，会造成内存泄漏。
所以析构函数要构成多态，p1指向的是基类，调用基类的析构即可；p2虽然是A*类型，但是p2指向派生类，与基类构成多态，可以成功调用B类型的析构函数B中的资源，并且在B的析构函数结束后也会自动调用A类型的析构函数，完美解决。

3.3override和final关键字

从上面可以看出，C++对虚函数重写要求比较严格，但是有些情况下由于疏忽，比如函数名写错参数写错等导致无法构成重写，而这种错误在编译器期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，**因此C++11提供了override，可以帮助用户检测是否重写。**如果我们不想让派生类重写这个虚函数，那么可以用final去修饰。

cpp 复制代码

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

cpp 复制代码

class Car
{
public://声明为"final"的函数无法被"Benz::Drive"重写
      virtual void Drive() final{}
};
/
class Benz:public Car
{
public:
      virtual void Drive(){cout<<"Benz-舒适"<<endl;}
}

💡四、重载/重写/隐藏的对比

注意：这个概念对比经常考，大家得理解记忆一下

☔五、纯虚函数和抽象类

在虚函数的后面写上=0，则这个函数为纯虚函数，纯虚函数不需要定义实现（实现没啥意义因为要被派生类，但是语法上可以实现），只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。纯虚函数某种程度强制了派生类重写虚函数，因为不重写实例化不出对象。

cpp 复制代码

class Car
{
public:
     virtual void Drive() = 0;
};
/
class Benz:public Car
{
public:
     virtual void Drive()
     {
         cout<<"Benz-舒适"<<endl;
     }
};
/
class BWM:public Car
{
public:
     virtual void Drive()
     {
         cout<<"BWM-操控"<<endl;
     }
};
int main()
{
    Car car;//编译报错，无法实例化出对象
    Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBWM = new BWM;
    pBWM->Drive();
}

⚡六、多态的原理

先来一道题目进行引入：
下面程序运行的结果是什么

cpp 复制代码

class Base
{
public:
     virtual void Func()
     {
        cout<<"Func()"<<endl;
     }
protected:
     int _b;
     char _c;
}
int main()
{
    Base b;
    cout<<sizeof(b)<<endl;
}

上面运行的结果是12，除了_b和_c成员，还多一个__vfptr放在对象的前面（注意平台可以会放到对象的最后面，这个跟平台有关），对象中的这个指针我们叫做虚函数表指针（v代表virtual，f代表function）。一个含有虚函数的类中都至少都有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。

6.1样例

代码示例，如下

cpp 复制代码

class Person
{
public:
     virtual void Buyticket(){cout<<"买票-全价"<<endl;}
private:
     string _name;
};
/
class Student:public Person
{
public:
     virtual void Buyticket(){cout<<"买票-打折"<<endl;}
private:
     string _id;
};
//
class Soidier:public Person
{
public:
    virtual void Buyticket(){cout<<"买票-优先"}
private:
    string _codename;
};
///
void Func(Person* ptr)
{
   ptr->Buyticket();
   //本质是运行时。指向哪个对象就去这个对象的虚函数表中找到对应的虚函数地址进行调用
}
int main()
{
   Person ps;
   Student st;
   Soldier sr;
   Func(&ps);
   Func(&st);
   Func(&sr);
   return 0;
}

6.2动态绑定和静态绑定

· 对不满足多态条件（指针或者引用+调用虚函数）的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。
· 满足多态条件的函数调用是在运行时绑定，也就是在运行时到指定对象的虚函数表中找到调用函数的地址，就叫做动态绑定。
还是拿刚才的代码举例子

cpp 复制代码

void Func(Person* ptr)
{
   ptr->Buyticket();
}
int main()
{
   Person ps;
   Student st;
   Soldier sr;
   Func(&ps);
   Func(&st);
   Func(&sr);
   return 0;
}

若Person::Buyticket()是虚函数

------>Func(&ps)。ps是Person类型，调用的是Person::Buyticket()，编译时就能确定函数，是静态绑定 。

------>Func(&st)和Func(&sr)。Student与Soldier都重写了Person中的Buyticket(),通过Person*调用虚函数，运行期间才会匹配，所以是动态绑定。

若Person::Buyticket不是虚函数

此时所有调用都是静态绑定

无论传入的是Person/Student/Soldier对象，Func都会根据指针的类型（Person*），直接调用Person::Buyticket(),不会触发多态。

6.3虚函数表

·基类对象的虚函数表中存放基类所有虚函数的地址 。同类型的对象公用同一张虚表，不同类型的对象各自有独立的虚表，所以基类和派生类有各自独立的虚表。（假设我们定义了两个Person对象，那么这两个对象中存放的虚函数表指针指向的都是同一块虚函数表）
**·**派生类由两部分构成，继承下来的基类和自己的成员，一般情况下，继承下来的基类中由虚函数表指针，自己就不会再生成虚函数表指针 。但是要注意的这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生类对象中的基类对象成员也独立的。
**·**派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖称派生类重写的虚函数地址（没重写就用父类的）。
**·**派生类的虚函数表中包含（1）基类的虚函数地址（2）派生类如果重写了基类虚函数，那么地址完成覆盖（3）派生类自己的虚函数地址。

🎓七、总结

本章主要讲解了多态的基础知识，任重而道远，希望大家多多思考，多多感悟，才能学好多态。