【前言】

需要声明的，本节课件中的代码及解释都是在 vs2022 下的 x86 程序中，涉及的指针都是 4bytes 。 如果要其他平台下，部分代码需要改动。比如：如果是 x64 程序，则需要考虑指针是 8bytes 问题 等等。

1. 多态的概念

1.1 概念

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

举个栗子：大家都吃过海底捞吧，那么海底捞对大学生有一个69折扣以及不同的人在其中的会员情况是不同的，大家去消费时，或许是同样的饭菜，但是由于你是大学生或者你有更高级的会员卡，那么你就能够享受到更加优惠的价格。

2. 多态的定义及实现

2.1多态的构成条件

我相信大家之前已经了解过一部分多态：我们C++入门时学习的函数重载其实就是一种静态的多态，当我们调用同一个函数会发生不同的行为，原理是编译时就已经实现了。

那动态的多态是什么呢？我们接下来会详细介绍：

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如 Student 继承了

Person 。 Person 对象买票全价， Student 对象买票69折扣。

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

• 必须通过基类的指针或者引用调用虚函数
• 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

那什么是虚函数呢？

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 << "买票-69折" << endl; }
};

在Student类中，就对Person类里面的虚函数BuyTicket进行了重写，另外值得注意的小细节是当父类写了虚函数时就算子类没有加virtual编译器也会被当作是重写，例如下面这种情况也是重写：

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

我们看下面这个程序：

#include<iostream>
using namespace std;
class Person {
public:
  virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
  virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void fun(Person& p)
{
  p.BuyTicket();
}
int main()
{
  Person p;
  Student s;
  fun(p);
  fun(s);
  return 0;
}

上面程序在fun函数中我们用了一个父类类型的形参引用来接受传入的参数，当传入的参数对象是Person类型时就调用父类的虚函数，当传入的参数对象是Student类型时就调用子类的虚函数，而同一个函数当不同的对象去调用时就产生了不同的行为，这种就是多态。我们让程序跑起来：

我们发现程序与我们预期的结果类似，至于多态的原理我们在后面会给出解释。

从这里我们应该也会发现这里的多态并不是编译时就产生的（因为编译并不知道你要用哪个对象来调用），而是运行时具体实例化出对象而产生的。

大家想想下面这段程序构成多态吗？

  p.BuyTicket();
  s.BuyTicket();

这其实只是普通的通过对象调用而已，并没有通过父类的指针或者引用来调用虚函数。

虚函数重写的两个例外：

1. 协变(基类与派生类虚函数返回值类型不同)

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指

针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

比如下面这段程序：

class A {};
class B : public A {};
class Person {
public:
  virtual A* f()
  { 
    cout << "virtual A* f()" << endl;
    return new A; 
  }
};
class Student : public Person {
public:
  virtual B* f() 
  { 
    cout << "virtual B* f() " << endl;
    return new B; 
  }
};
void fun(Person& p)
{
  p.f();
}
int main()
{
  Person p;
  Student s;
  fun(p);
  fun(s);
  return 0;
}

虽然父类中虚函数的返回值类型不等于子类中虚函数的返回值类型，但是他们依然是构成重写的，我们运行程序看看：

不难发现虚函数已经成功重写了。

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

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，

都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同 ， 看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处 理，编译后析构函数的名称统一处理成 destructor 。

我们看看下面这段程序：

class Person {
public:
  virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
  virtual ~Student() { cout << "~Student()" << endl; }
};
int main()
{
  Person* p1 = new Person;
  Person* p2 = new Student;
  delete p1;
  delete p2;
  return 0;
}

我们我们new了一个Student类型的对象用了一个Person类型的指针来接受，假如Student类中的析构函数没有对Person类中的析构函数进行重写，那么当析构p2时不是就只调用Person类的析构函数，当Student类中有额外资源不就造成了内存泄漏了吗？所以在这里编译器会对析构函数做出特殊处理，会将析构函数的名字统一处理为destructor，这样就构成了多态。当然如果是下面这种用法就不会是多态了，就与我们之前讲解继承那儿一样为普通情况：

  Person* p1 = new Person;
  Student* p2 = new Student;
  delete p1;
  delete p2;

这时父类与子类中的析构函数构不构成多态已经不重要了，因为他们会各自调用自己的析构函数处理，这点大家一定不要被误导了。

2.4 C++11 override 和 final

从上面可以看出， C++ 对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数

名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有

得到预期结果才来 debug 会得不偿失。如果在c98时我们想要一个类不能够被继承，我们应该怎么做？

这时我们只需要将该类的构造函数设置为私有，那么该类就无法继承了：

class A
{
private:
  A(int a=10)
    :_a(a)
  {}
  int _a;
};
class B :public A
{
private:
  int _b;
};
int main()
{
  B b;
  return 0;
}

我们创建一个B类型的对象试试：

我们甚至连A类型的对象都已经无法创建，那么假如已经确定了A类的构造函数私有了，那么如何构造出一个A类型的对象呢，这里可以用单例模式来处理：

class A
{
private:
  A(int a=10)
    :_a(a)
  {}
  int _a;
public:
  static A GetOBJ(int a=10)
  {
    A* obj = new A(a);
    return *obj;
  }
};
class B :public A
{
private:
  int _b;
};
int main()
{
  A a = A::GetOBJ(12);
  return 0;
}

这里我们创建对象用的是类域来访问类的静态成员函数，这样就很好的避免了用对象来访问在这种情况的尴尬之处。

但是C++11提供了final，用final修饰类表示该类不可以被继承。

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

 用final修饰虚函数表示该虚函数不能够被重写：

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

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