多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

下面的实例中，基类 Shape 被派生为两个类，如下所示：

  1. #include <iostream>
  3. using namespace std;
  5. class Shape
  6. {
  7. protected:
  8.   int width, height;
  10. public:
  11.   Shape(int a = 0, int b = 0)
  12.   {
  13.     width = a;
  14.     height = b;
  15.   }
  16.   int area()
  17.   {
  18.     cout << "Parent class area" << endl;
  19.     return 0;
  20.   }
  21. };
  23. class Rectangle : public Shape
  24. {
  25. public:
  26.   Rectangle(int a = 0, int b = 0) : Shape(a, b) {}
  27.   int area()
  28.   {
  29.     cout << "Rectangle class area: " << width * height << endl;
  30.     return (width * height);
  31.   }
  32. };
  34. class Triangle : public Shape
  35. {
  36. public:
  37.   Triangle(int a = 0, int b = 0) : Shape(a, b) {}
  38.   int area()
  39.   {
  40.     cout << "Triangle class area: " << width * height / 2 << endl;
  41.     return (width * height / 2);
  42.   }
  43. };
  45. int main()
  46. {
  47.   Shape *shape;
  48.   Rectangle rec(10, 7);
  49.   Triangle tri(10, 5);
  51.   shape = &rec;    // 存储矩形的地址
  52.   shape->area();   // 调用矩形的求面积函数 area
  53.   // rec.area();   //这样子输出是正确的 Rectangle class area
  55.   shape = &tri;    // 存储三角形的地址
  56.   shape->area();   // 调用三角形的求面积函数 area
  57.   // tri.area();   //这样子输出是正确的 Triangle class area
  59.   return 0;
  60. }
  62. /* 
  63. Parent class area
  64. Parent class area 
  65. */

导致错误输出的原因是，调用函数 area() 被编译器设置为基类中的版本，这就是所谓的静态多态，或静态链接
函数调用在程序执行前就准备好了。有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。
但现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示：

  1. #include <iostream>
  2. using namespace std;
  4. class Shape
  5. {
  6. protected:
  7.   int width, height;
  9. public:
  10.   Shape(int a = 0, int b = 0)
  11.   {
  12.     width = a;
  13.     height = b;
  14.   }
  15. + virtual int area() // ➕ ✅
  16.   {
  17.     cout << "Parent class area:" << endl;
  18.     return 0;
  19.   }
  20. };
  22. class Rectangle : public Shape
  23. {
  24. public:
  25.   Rectangle(int a = 0, int b = 0) : Shape(a, b) {}
  26.   int area()
  27.   {
  28.     cout << "Rectangle class area: " << width * height << endl;
  29.     return (width * height);
  30.   }
  31. };
  33. class Triangle : public Shape
  34. {
  35. public:
  36.   Triangle(int a = 0, int b = 0) : Shape(a, b) {}
  37.   int area()
  38.   {
  39.     cout << "Triangle class area: " << width * height / 2 << endl;
  40.     return (width * height / 2);
  41.   }
  42. };
  44. int main()
  45. {
  46.   Shape *shape;
  47.   Rectangle rec(10, 7);
  48.   Triangle tri(10, 5);
  50.   shape = &rec;  // 存储矩形的地址
  51.   shape->area(); // 调用矩形的求面积函数 area
  53.   shape = &tri;  // 存储三角形的地址
  54.   shape->area(); // 调用三角形的求面积函数 area
  56.   return 0;
  57. }
  59. /* 
  60. Rectangle class area: 70
  61. Triangle class area: 25
  62. */

此时，编译器看的是指针的内容，而不是它的类型。因此，由于 rec 和 tri 类的对象的地址存储在 shape 中，所以会调用各自的 area() 函数。
正如您所看到的，每个子类都有一个函数 area() 的独立实现。这就是*多态的一般使用方式。有了多态，您可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。

虚函数

虚函数是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。
我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为 动态链接，或后期绑定

纯虚函数

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。
我们可以把基类中的虚函数 area() 改写如下：

  1. class Shape {
  2.    protected:
  3.       int width, height;
  4.    public:
  5.       Shape( int a=0, int b=0)
  6.       {
  7.          width = a;
  8.          height = b;
  9.       }
  11.       virtual int area() = 0; // pure virtual function
  12. };

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数