C++入门12——详解多态1

1.多态的概念

每逢春节假期，各大娱乐平台都会推出“集卡除夕夜瓜分亿万红包”活动，可同样集卡成功了，有的人红包几块钱，有的人红包却几毛钱......为什么不同的人得到的红包却不相同呢？那是因为平台会根据你的用户数据，比如可能你是新用户、可能你在活动期间活动完成率高......那么你的红包就有可能比别人大一点。

其实这背后就是就是一个多态行为：同样的一个集卡开红包行为，不同的人得到的结果却不相同。

所以多态通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会 产生出不同的状态。

2.多态的定义与实现

2.1多态构成的条件

1中已经说了，多态是在不同继承关系的类对象，去调用同一函数，却产生了不同的行为。比如Unluck_Peo继承了Luck_Peo。Luck_Peo对象的红包是五块，Unluck_Peo对象的红包却是五毛。

那么在继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数；

2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

举个例子：

class Luck_Peo
{
public:
  virtual void Red_Packet()
  {
    cout << "五块红包" << endl;
  }
};
 
class Unluck_Peo:public Luck_Peo
{
public:
  virtual void Red_Packet()
  {
    cout << "五毛红包" << endl;
  }
};
 
void Func(Luck_Peo& p)
{
  p.Red_Packet();
}
 
int main()
{
  Luck_Peo lp;
  Unluck_Peo up;
  Func(lp);
  Func(up);
  return 0;
}

也许到这里还并不能完全理解这段代码的意思，别着急，接下来就让我们了解一下：

2.2虚函数

在上篇文章C++入门11——详解C++继承（菱形继承与虚拟继承）中我们知道，为了解决菱形继承的弊端，C++就引入了虚拟继承，即：被virtual修饰的继承关系成为虚拟继承，相同的道理，虚函数就是被virtual修饰的类成员函数称为虚函数。

举个例子：

class Luck_Peo
{
public:
  //virtual修饰成员函数表示虚函数
  virtual void Red_Packet()
  {
    cout << "五块红包" << endl;
  }
};

2.3虚函数的重写

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

正如我们之前的代码：

class Luck_Peo
{
public:
  virtual void Red_Packet()
  {
    cout << "五块红包" << endl;
  }
};
 
class Unluck_Peo:public Luck_Peo
{
public:
  virtual void Red_Packet()
  {
    cout << "五毛红包" << endl;
  }
};
//*void Red_Packet() { cout << "五毛红包" << endl; }
// 注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，
// 其实也是可以构成重写的(因为继承后基类的虚函数被继承下来了，在
// 派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用
 
void Func(Luck_Peo& p)
{
  p.Red_Packet();
}

虚函数重写的两个例外：

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; 
  }
};

2.析构函数的重写(基类与派生类析构函数的名字不同)

在C++入门11——详解C++继承（菱形继承与虚拟继承）中，我们已经知道了父类与子类的析构顺序为先子后父：

class Person
{
public:
  ~Person()
  {
    cout << "~Person()" << endl;
  }
};
class Student:public Person
{
public:
  ~Student()
  {
    cout << "~Student()" << endl;
  }
};
 
int main()
{
  Person p;
  Student s;
  return 0;
}

（如果对此运行结果有疑惑的铁铁，可以查看我的上一篇文章对于C++继承中子类与父类对象同时定义其析构顺序的探究）

现在，我要创建两个父类指针分别指向父类对象和子类对象：

int main()
{
  //Person p;
  //Student s;
 
  Person* p1 = new Person;
  delete p1;
  Person* p2 = new Student;
  delete p2;
  return 0;
}

从运行结果看子类的析构函数并没有被调用，这必然会引起内存泄漏啊！

很明显，这里的调用明显是普通调用：只关注指针、引用、对象的类型；由于两个指针的类型都是Person，所以只调用了Person的析构函数；

而这里我需要的是多态调用：关注指针或引用指向的对象；正确的结果应该是指针指向父类我就调父类的析构函数，指针指向子类我就调用子类的析构函数。

那么如何引发多态呢？上述代码中，我们已经完成了多态构成的条件的第一条，现在的问题无非就是析构函数的重写了呀！

可是虚函数的重写又要保证“三同”，很明显，父类的析构函数名与子类的析构函数名根本不可能相同啊！如何解决这个问题呢？其实在C++入门11——详解C++继承（菱形继承与虚拟继承）提了一嘴：子类的析构函数与父类的析构函数构成隐藏关系，由于多态的原因，析构函数会被特殊处理，函数名都会被处理成destrutor()。

所以析构函数的重写就可以总结为：

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

规范的代码应该为：

class Person {
public:
  virtual ~Person() 
  { 
    cout << "~Person()" << endl; 
  }
};
class Student : public Person {
public:
  virtual ~Student() 
  { 
    cout << "~Student()" << endl; 
  }
};
// 只有派生类Student的析构函数重写了Person的析构函数，
// 下面的delete对象调用析构函数，才能构成多态，
// 才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
  Person* p1 = new Person;
  delete p1;//p1->destructor() + operator delete(p1)
  Person* p2 = new Student;
  delete p2;//p2->destructor() + operator delete(p2)
  return 0;
}

2.4 C++11 override 和 final

在之前的文章中我们了解到，final修饰的类表示该类为最终类，不能被继承。其实，final除了有这个用处之外还能够修饰虚函数：

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

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

class A
{
public:
  virtual void Func() final {}
};
class B :public A
{
public:
  virtual void Func() {}
};

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

class A {
public:
  //void Func() {} //error：使用“override”声明的成员函数不能重写基类成员
  virtual void Func() {}
};
class B :public A 
{
public:
  virtual void Func() override {}
};

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

3.抽象类

抽象这个词近些年成了热梗：这个人真抽象！这个人长得真抽象！当然这些词也都褒贬不一，不过抽象的意思总的来说有被常人不能理解的意思。

那么在C++中，抽象类又是什么呢？

3.1抽象类的概念

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

那么抽象类会用到哪些场景呢？

比如实现一个手机品牌的管理系统：每个手机品牌都有自己的独到之处，那我就把不同手机品牌的基本特征提取出来放到一个公共的类-手机类，然后不同的手机品牌再去继承这个手机类。

在这段描述中，手机类没有实体，不需要实例化出对象，每一个手机品牌类才有对应的有实体，所以手机类应该是抽象的，手机类的这些派生类-手机品牌类才应该是具象的。

举个例子：

#include <iostream>
using namespace std;
 
//抽象类
class Phone
{
public:
  //纯虚函数
  virtual void Trait() = 0;
};
class Redmi :public Phone
{
public:
  //由于派生类继承了基类，所以派生类也实例化不出对象
  //如果想要实例化出对象就必须重写虚函数
  //也就是说，抽象类间接地强制了子类重写虚函数
  virtual void Trait()
  {
    cout << " Redmi-> 性价比之王" << endl;
  }
};
class HuaWei :public Phone
{
public:
  virtual void Trait()
  {
    cout << " HuaWei->遥遥领先" << endl;
  } 
};
 
 
int main()
{
  //抽象类实例不出对象
  //Phone p;        //error:不允许使用抽象类类型“phone”的对象
 
  Phone* p = new Redmi;
  p->Trait();
  p = new HuaWei;
  p->Trait();
  return 0;
}

（抽象类具体什么时候用呢？比如在整个体系中我们不期望父类实例化出对象，并且父类的某些函数必须要求其子类重写，这时候就可以考虑用到抽象类）

3.2 接口继承和实现继承（了解一下）

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现；

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