C++篇之多态

1，多态的概念

多态的概念：普通的来讲，就是多种形态。多态分为编译时多态（静态多态）和运行时多态（动态多态）。这里主要讲的是运行时多态。
   编译时多态：比如函数重载和函数模板，通过传差别类型的参数就可以调用差别的函数，通过参数差别到达多态，之以是叫编译时多态，是因为他们实参传给形参的参数匹配是在 编译时完成的，我们把编译时⼀般归为静态，运⾏时归为动态。
    运行时多态：具体点就是去完成某个⾏为(函数)，可以传差别的对象就会完成差别的⾏为，就到达多种 形态。
  用生存中的一种例子来讲，比如买票这个行为：当学生买票时是半价，而当是成年人买票时就是全价。有几种差别的状态。
2，多态的界说及实现

2.1，虚函数

   类成员函数前⾯加virtual修饰，那么这个成员函数被称为虚函数。留意⾮成员函数不能加virtual修饰。
  2.2，虚函数的重写 

   虚函数的重写/覆盖：派⽣类中有⼀个跟基类完全相同的虚函数(即派⽣类虚函数与基类虚函数的返回值 类型、函数名字、参数列表完全相同)，称派⽣类的虚函数重写了基类的虚函数。
  注：基类的重写虚函数可以加上virtual，也可以不加，一样平常建议加上 
  2.3，多态的构成条件

   多态是在继承关系下形成的。条件如下图：
  

示例：

  

   总结：要实现多态结果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向派⽣ 类对象；第⼆派⽣类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派⽣类才能有差别的函数，多 态的差别形态结果才能到达。 
   2.4，协变

   派⽣类重写基类虚函数时，与基类虚函数返回值类型差别。即基类虚函数返回基类对象的指针或者引 ⽤，派⽣类虚函数返回派⽣类对象的指针或者引⽤时，称为协变。
  示例：
   class A {};
class B :public A{};
class Person
{
public:
    virtual A* BuyTicket()
    {
        cout << "person买票全价" << endl;
        return nullptr;
    }
};
class Student :public Person
{
public:
    virtual B* BuyTicket()
    {
        cout << "Student买票半价" << endl;
        return nullptr;
    }
};
//这里参数也可以使用指针
void func(Person& p)
{
    p.BuyTicket();
}
  int main()
{
    Person p;
    func(p);
      Student s;
    func(s);
    return 0;
}
  
  2.5，析构函数的重写 

   如果基类的析构函数为虚函数，那么派生类的虚函数只要界说，无论是否加virtual，都与基类的析构函数构成重写。
  固然他们的函数名差别，但可以理解为编译器做了特殊处理，编译后析构函数同一名称为destructor。
  为什么要重写析构函数？下面的代码解释：（没有实现析构函数重写）

1. class A
2. {
3. public:
4.     ~A()
5.     {
6.         cout << "~A()" << endl;
7.     }
8. };
9. class B :public A
10. {
11. public:
12.     ~B()
13.     {
14.         cout << "~B()::p->" << p<<endl;
15.         delete p;
16.     }
17. protected:
18.     int* p = new int[10];
19. };
21. int main()
22. {
23.     A* p1 = new A;
24.     A* p2 = new B;
26.     delete p1;
27.     delete p2;
28.     return 0;
29. }

复制代码

 运行结果：

   可以看出，两个对象都调用的是A的析构，而p2new的是B类型的对象，应该调用B的析构， 如许就会造成内存泄漏的问题。以是需要对析构函数进行重写，在执行delete p2时，A和B的析构函数构成多态，回去调用B的析构函数，释放资源p;

1. class A
2. {
3. public:
4.     virtual ~A()
5.     {
6.         cout << "~A()" << endl;
7.     }
8. };
9. class B :public A
10. {
11. public:
12.     virtual ~B()
13.     {
14.         cout << "~B()::p->" << p<<endl;
15.         delete p;
16.     }
17. protected:
18.     int* p = new int[10];
19. };
21. int main()
22. {
23.     A* p1 = new A;
24.     A* p2 = new B;
26.     delete p1;
27.     delete p2;
28.     return 0;
29. }

复制代码

运行结果：

 这里最后会再调用A的析构，是因为继承的原因。内容在上一节中。
2.6，override和final关键字

   如果我们不想让派生类去重写该函数，可以用final修饰。
  override可以检测虚函数是否重写成功。
  

2.7，重写/重载/隐藏的对比 

3，纯虚函数和抽象类

    在虚函数的后⾯写上=0，则这个函数为纯虚函数，纯虚函数不需要界说实现，只要声明即可
  。包罗纯虚函数的类叫做抽象类，抽象类不能实例 化出对象，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种水平上强制了 派⽣类重写虚函数，因为不重写实例化不出对象
  4，多态的原理 

   ⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针，因为⼀个类所有虚函数的地址要 被放到这个类对象的虚函数表中，虚函数表也简称虚表。
    class Base
{
public:
    virtual void Func1()
    {
        cout << "Func1()" << endl;
    }
protected:
    int _b = 1;
    char _ch = 'x';
};
  int main()
{
    Base b;
    cout << sizeof(b) << endl;
    return 0;
}
  //运行结果   16
  

 

由上图调试代码可以看出，除了_b和_ch成员，还多⼀个__vfptr放在对象的前⾯ ，这个指针就叫做虚函数表指针。
总结如下图所示：

1. class Base
2. {
3. public:
4.     virtual void Func1()
5.     {
6.         cout << "Base::Func1()" << endl;
7.     }
8.     virtual void Func2()
9.     {
10.         cout << "Base::Func2()" << endl;
11.     }
12. protected:
13.     int _b = 1;
14. };
16. class Drive :public Base
17. {
18. public:
19.     virtual void Func1()
20.     {
21.         cout << "Drive::Func1()" << endl;
22.     }
24. };
25. int main()
26. {
27.     Base b;
28.     Drive d;
29.    
30.     return 0;
31. }

复制代码

 

从上图可以看出,d的虚函数表包罗了重写的func1，也包罗了基类的虚函数func2,此中func2没有被重写。 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。