C++ 动态多态

背景

以前的学习，只是简单地知道：**面向对象的三大特性(封装、继承、多态) **，在项目开发中，用到了多态而自己却不知道。

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。（调用同名函数却会因上下文的不同而有不同的实现。）

引用Charlie Calverts对多态的描述：多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说：允许将子类类型的指针赋值给父类类型的指针。

多态三要素：相同函数名、依据上下文、实现却不同；

多态分为2种：静态多态(重载)，动态多态。

• 静态多态实际上就是函数重载，是编译器在编译期间完成的，所以称之为静态。
• 动态多态： 通过继承重写基类的虚函数实现的多态，在程序运行时根据基类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。 运行时在虚函数表中寻找调用函数的地址。

下面我们重点介绍动态多态(下文称 多态)

动态多态的概念

多态的常规用法：用一个父类的指针去调用子类中被重写的方法。

为什么不直接在子类中写一个同名的成员函数，从而隐藏父类的函数就好了？

举个例子：

将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但是也各不相同。如果我在写驱动的时候，我用父类表示外设接口，然后在子类中重写父类那个读取设备的虚函数，那这样电脑的外设接口只需要一个。但如果我不是这样做，而是用每个子类表示一个外设接口，那么我的电脑就必须有3个接口分别来读取移动硬盘、U盘以及MP3。若以后我还有SD卡读卡器，那我岂不是要将电脑拆了，焊个SD卡读卡器的接口上去？

用父类的指针指向子类，是为了面向接口编程。大家都遵循这个接口，弄成一样的，到哪里都可以用，准确说就是："一个接口，多种实现"。

多态的使用

使用多态必须满足以下条件

• 基类中必须包含虚函数，并且派生类中一定要对基类中的虚函数进行重写。
• 通过基类对象的指针或者基类对象的引用**调用虚函数。

在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。

在成员函数(必须为虚函数)的形参列表后面写上=0，则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。纯虚函数在派生类中重新定义以后，派生类才能实例化出对象。纯虚函数是一定要被继承的，否则它存在没有任何意义。

如果对象类型是子类，就调用子类的函数；如果对象类型是父类，就调用父类的函数，（即指向父类调父类，指向子类调子类）此为多态的表现。

/*
#    Copyright By Schips, All Rights Reserved
#    https://gitee.com/schips/
#
#    File Name:  Polymorphism.cpp
#    Created  :  2020年02月21日 11:17:42
*/

#include <iostream>
using namespace std;
class base
{
public:
    virtual void go();
};

void base :: go ()
{
    cout << "base.go" << endl;
}

class sub : public base
{
public:
    virtual void go();
};

void sub :: go ()
{
    cout << "sub.go" << endl;
}

void fun (base& p)
{
     p.go ();
}

int main(int argc, char *argv[])
{
    base b;
    sub s;
    // 通过 基类引用的方式
    fun(b);
    fun(s);

    // 通过 基类指针的方式
    base *pb = &b;
    pb->go();
    pb = &s;
    pb->go();

    return 0;
}

多态的原理

多态是基于 虚函数表实现的。

虚函数表

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

假设有这样的一个类：

class Base
{
public:

    virtual void f (){cout<<"Base::f()"<<endl;}
    virtual void g() {cout<<"Base::g()"<<endl;}
    virtual void h() {cout<<"Base::h()"<<endl;}

};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。 下面是实际例程：

typedef void(*Fun)(void); 

Base b; 

Fun pFun = NULL; 

cout << "虚函数表地址：" << (int*)(&b) <<endl;

cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) <<endl;

pFun = (Fun)*((int*)*(int*)(&b)); 

pFun();

通过这个示例，我们可以看到，我们可以通过强行把&b转成int ，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int 强制转成了函数指针）。通过这个示例，我们也就可以知道如果要调用Base::g()和Base::h()，其代码如下：

(Fun)*((int*)*(int*)(&b)+0); // Base::f() 

(Fun)*((int*)*(int*)(&b)+1); // Base::g() 

(Fun)*((int*)*(int*)(&b)+2); // Base::h()

以上实例如图所示：

注意：在上面这个图中，在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

虚函数的 “无覆盖”和“有覆盖”

没有覆盖父类的虚函数是毫无意义的。之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

a.一般继承（无虚函数覆盖）

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载(重写)任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

b.一般继承（有虚函数覆盖）

覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧存在。

这样，我们就可以看到对于下面这样的程序，

Base *b = new Derive();
b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

多重继承（无虚函数覆盖）

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：

1） 每个父类都有自己的虚表。

2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

多重继承（有虚函数覆盖）

下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

Derive d; 

Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d; 

b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()
b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()

virtual是让子类与父类之间的同名函数有联系，这就是多态性，实现动态绑定。

任何类若是有虚函数就会比比正常的类大一点，所有有virtual的类的对象里面最头上会自动加上一个隐藏的，不让开发者知道的指针，它指向一张表，这张表叫做vtable，vtable里是所有virtual函数的地址。

派生类虚表：

1.先将基类的虚表中的内容拷贝一份

2.如果派生类对基类中的虚函数进行重写，使用派生类的虚函数替换相同偏移量位置的基类虚函数

3.如果派生类中新增加自己的虚函数，按照其在派生类中的声明次序，放在上述虚函数之后

为什么要把基类的析构函数定义为虚函数？

解答：

在用基类操作派生类时，为了防止执行基类的析构函数，不执行派生类的析构函数。因为这样的删除只能够删除基类对象, 而不能删除子类对象, 形成了删除一半形象, 会造成内存泄漏.如下代码：

#include<iostream>
using namespace std;  

class Base
{
public:
    Base() {};
    //virtual ~Base()   // 会导致先析构子类
    ~Base()   // 不析构子类 ，存在内存泄漏
    {
        cout << "delete Base" << endl;
    };  

};  

class Derived : public Base
{
public:
    Derived() {};
    ~Derived()
    {
        cout << "delete Derived" << endl;
    };
};  

int main()
{
    //操作1
    Base* p1 = new Derived;
    delete p1;  

    //因为这里子类的析构函数重写了父类的析构函数，虽然子类和父类的析构函数名不一样，
    //但是编译器对析构函数做了特殊的处理，在内部子类和父类的析构函数名是一样的。
    //所以如果不把父类的析构函数定义成虚函数，就不构成多态，由于父类的析构函数隐藏了子类
    //的析构函数，所以只能调到父类的析构函数。  （导致子类的析构函数没有执行）
    //但是若把父类的析构函数定义成虚函数，那么调用时就会直接调用子类的析构函数，
    //由于子类析构先要去析构父类，在析构子类，这样就把子类和继承的父类都析构了  

}

多态 注意事项

使用多态时，让基类的析构函数成为 虚函数。

虚函数的定义要遵循以下重要规则：

1.如果虚函数在基类与派生类中出现，仅仅是名字相同，而形式参数不同，或者是返回类型不同，那么即使加上了virtual关键字，也是不会进行滞后联编的。

2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数。

3.静态成员函数不能是虚函数,因为静态成员函数的特点是不受限制于某个对象。

4.内联(inline)函数不能是虚函数，因为内联函数不能在运行中动态确定位置。即使虚函数在类的内部定义定义，但是在编译的时候系统仍然将它看做是非内联的。

5.构造函数不能是虚函数，因为构造的时候，对象还是一片位定型的空间，只有构造完成后，对象才是具体类的实例。

6.析构函数可以是虚函数,而且通常声名为虚函数。

下面的几个函数都不能定义为虚函数：

1）友元函数，它不是类的成员函数

2）全局函数

3）静态成员函数，它没有this指针

3）构造函数，拷贝构造函数，以及赋值运算符重载（可以但是一般不建议作为虚函数）

多态 的 缺点

• 降低了程序运行效率（多态需要去找虚表的地址）
• 空间浪费