但现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示

多态的作用

这就是多态的一般使用方式。有了多态，您可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。

在面向对象编程范式中，多态性往往表现为”一个接口，多个功能

  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.       }
  10.       // pure virtual function
  11.       virtual int area() = 0;
  12. };

动态联编支持多态性

定义

编译程序在编译阶段并不能确切地指导将要调用的函数，只有在程序执行时才能确定将要调用的函数，为此要确切地指导将要调用的函数，要求联编工作在程序运行时进行，这种在 程序运行时进行的 联编工作被称为动态联编。 C++中，动态联编是在虚函数的支持下实现的 。

例子

  1. #include<iostream>
  3. using std::cout;
  4. using std::endl;
  6. class Parent
  7. {
  8. public:
  9.     virtual void show()            //虚函数show
  10.     {
  11.         cout << "parent" << endl;
  12.     }
  13.     void put()
  14.     {
  15.         cout << "基类" << endl;
  16.     }
  17. };
  19. class Son : public Parent
  20. {
  21. public:
  22.     void show()
  23.     {
  24.         cout << "son" << endl;
  25.     }
  27.     void put()
  28.     {
  29.         cout << "派生类" << endl;
  30.     }
  31. };
  33. void fun(Parent& p)
  34. {
  35.     p.show();
  36. }
  38. void fun(Parent& p,int)            //使用占位参数重载fun。
  39. {
  40.     p.put();
  41. }
  43. int main()
  44. {
  45.     Parent* p = nullptr;
  46.     p = new Son;
  48.     Parent p1;
  50.     fun(p1);            //父类
  51.     fun(*p);            //子类
  53.     cout << endl;
  55.     fun(p1, 1);            //父类
  56.     fun(*p, 1);            //子类
  58.     delete p;
  59.     p = nullptr;
  61.     return 0;
  62. }

很明显，静态联编在编译的时候就和被调函数绑定了，只会去调用基类的put成员函数，根本不会调用派生类重写的put成员

子类对象代替父类对象作为函数入口参数

当入口参数为父类对象时，子类即便作为入口参数，最后使用的仍然是父类的方法，而入口参数是父类指针或者父类引用时，子类代替父类作为入口参数，就可以使用自己的方法。

例子

  1. #include <iostream>
  2. using namespace std;
  3. class A
  4. {
  5. public:
  6.     virtual void Show() const
  7.     { 
  8.         cout << "A "; 
  9.     }
  10. };
  11. class B: public A
  12. {
  13. public:
  14.     void Show() const
  15.     { cout << "B "; }
  16. };
  18. void Show(const A &obj) {
  19.     obj.Show(); 
  20. }
  21. int main()
  22. {
  23.     A a; B b; 
  24.     Show(a); Show(b);
  25.     A *p;
  26.     p = &a; p->Show();
  27.     p = &b; p->Show();
  28.     B *q;
  29.     q = &b; q->Show();
  30.     cout << endl;
  31.     return 0; 
  32. }

这里 line 18 传递参数为父类的引用，因此可以调用子类的函数。