C++相关概念和易错语法（21）（虚函数、协变、析构函数的重写）

多态的核心是虚函数，本文从虚函数出发，根据原理慢慢推进得到结论，进而理解多态

1.虚函数

先看一下下面的代码，想想什么导致了这个结果

#include <iostream>
using namespace std;class A
{
public:virtual void test(){cout << "A" << endl;;}
};class B : public A
{
public:void test(){cout << "B" << endl;;}
};class C : public B
{
public:void test(){cout << "C" << endl;;}
};void Test(A& r)
{r.test();
}int main()
{A a;B b;C c;Test(a);Test(b);Test(c);return 0;
}

结果是

如果我们去掉A里面的virtual呢？

我们可以看到前后两次结果不同，为什么呢？函数形参为什么是以A&来接收的，调用时为什么还有区别呢？这就需要接触虚函数了。

（1）虚函数和虚函数表

当我们在父类声明了一个虚函数后，这个函数就被存在常量区了，同时在这个类里又多了一个新的隐藏成员，叫虚函数表（这个成员要算在整个类的大小里面）。这个虚函数表就是专门存虚函数的地址的（本质是函数指针数组，根据不同机器指针大小也不同）。对于父类而言，无论创建多少对象，它们都共用一个虚函数表（即对于同一种类，函数都是一样的）。这里要分清：虚函数是存在常量区的而不存在类里，类中存的是虚函数表。

（2）重写

虚函数有什么用呢？当子类实现一个和父类虚函数函数名、参数、返回值完全一样的函数时，就叫做重写。重写是一种特殊的隐藏，是在多态中的一种语法，而隐藏只要求函数名相同，是继承中的语法。重写的意义在于子类也有一个新的虚函数表，虽然函数前没有加声明virtual（父类前必须加），当子类显式写了这个函数，就会存到常量区，虚函数表存函数的地址（第一句指令的地址）。对于这个子类，无论创建多少个对象，它们都使用同一个针对子类的虚函数表。如果说有多个虚函数而子类没有重写，那个没有重写的函数就使用父类的对应的函数（反正没区别）。

（3）对多态的理解

到这里，我们对虚函数表、虚函数和重写有了一定了解，实际就是在最初的父类的函数前加上virtual，让该函数进入虚函数表，子类重写会让虚函数表存的函数不同，在调用的时候明明是调用的同一个函数，但得到的结果是针对每一种类不同的。这就叫多态，即多种形态，针对不同的类有不同的表现形态。

（4）对多态调用方式的理解

函数形参为什么是以A&来接收的？

我们进一步关注Test(A& r)这个函数，前面我们讲了赋值兼容转换，因此当B和C传进去的时候，r都会指向子类中的父类部分，这里相当于给它们的父类部分取别名。也就是说，r无论接收的是A还是B还是C，最终都会被切割成A的模样（A中也有虚函数表），但是内容是不是都一样呢？

很明显，虚函数表的作用就凸显出来了，A、B、C都有一个虚函数表，在B、C切割成A后，虚函数表被保留了下来，当我们用r去调用虚函数时，编译器会默认去虚函数表找到对应的函数（三种虚函数表的函数在函数名、参数、返回值上都相同，但存的函数地址不同），根据不同的函数地址就能找到不同的函数实现，这也是重写的意义所在。

至此，我们应该能够理解前面所说虚函数、虚函数表、重写存在的意义了，它们的出现都最终服务于实现一件事——多态，即根据不同类，在调用同一函数时体现出不同状态。

（5）是否有其它调用方式？

事实上，使用A&调用本质就是利用了赋值兼容转换，将多个子类都切割成父类的形式，再根据它们虚函数表的值的差异，调用不同的同名函数，体现出类与类之间的区别。很明显，除了引用，指针也适合，但赋值呢？赋值不是也遵循赋值兼容转换吗？

从实验上看是不行的，但也好理解。r都已经完全变成A类型了，再去调用B或C的成员就不太说得过去了。你可以将这里理解成一种特殊处理，支不支持都说得过去，但从形式上来说不支持更合理。

（6）多态的条件

很多课程都喜欢先说条件再将原因，而如果我们慢慢推进，到这里自然就理解了。

多态需满足条件：父类函数（想和子类形成差异的第一个函数就叫父类函数）写virtual（父类如果不写virtual而子类写virtual，那第一个写virtual的才叫父类，你可以将virtual当作一个多态开始的标志），后续的所有子类写不写virtual无所谓；子类覆盖/重写父类的虚函数；调用时使用父类的指针或引用，特别注意不能用赋值。

2.协变

上面说过要重写函数，必须保证函数的函数名、参数、返回值相同。但有唯一一个例外可以在返回值不同时能构成重写，就是协变（基本不用），即返回值可以是父子类的引用或指针。

下面这段代码是能跑过的

#include <iostream>
using namespace std;class A
{
public:virtual A& test(){cout << "A" << endl;;return *this;}
};class B : public A
{
public:B& test(){cout << "B" << endl;;return *this;}
};void Test(A& r)
{r.test();
}int main()
{A a;B b;Test(a);Test(b);return 0;
}

注意，返回值可以加const，返回值也可以是其它类，但必须是父子关系

#include <iostream>
using namespace std;class C
{};class D : public C
{};class A
{
public:virtual const C* test(){cout << "A" << endl;C* c = new C;return c;}
};class B : public A
{
public:const D* test(){cout << "B" << endl;D* d = new D;return d;}
};void Test(A& r)
{r.test();
}int main()
{A a;B b;Test(a);Test(b);return 0;
}

注意父子关系顺序不能反，父类返回值对应父类的虚函数

协变几乎不用，了解即可。我们大部分情况还是要保证函数名、参数、返回值相同，讨论的时候也是跳过这个特殊情况的。

3.析构函数的重写

理解析构函数的重写可以加深我们对析构函数的理解，顺便能够解释为什么所有的析构函数都会被处理成destructor()

#include <iostream>
using namespace std;class A
{
public:~A(){cout << "A" << endl;}
};class B : public A
{
public:~B(){cout << "B" << endl;delete p;}int* p;
};int main()
{A* a = new B;delete a;return 0;
}

这段代码会导致内存泄漏，因为当delete a的时候，会根据a的类型去调用析构函数，这里就只会去调用A的析构函数

联系到上面的重写，很快我们就会想到使用virtual修饰父类的析构函数，让析构函数进入虚函数表。但是很明显父类和子类的类名是不可能相同的，所以类的析构函数做了特殊处理：即都重命名为~destructor()，这样就符合了虚函数的要求

我们可以看到，这里根据虚函数表就能成功调到子的析构函数了，同时对于所有继承而言，子的析构调用完成之后都会逐级向上调用父的析构函数