前言

通过前两篇博文，我曾经将多态的前提条件总结得七七八八了。这一篇开始正式开展讲多态，以及咱们为什么要应用多态。

多态

什么是多态

援用百度百科的定义：

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现形式即为多态。援用 Charlie Calverts 对多态的形容——多态性是容许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就能够依据以后赋值给它的子对象的个性以不同的形式运作（摘自“Delphi4 编程技术底细”）。简略的说，就是一句话：容许将子类类型的指针赋值给父类类型的指针。

我的了解是：子类能够通过父类的指针或者援用，调用子类重写父类的虚函数，以达到一个类型多种状态的成果。

这听起来如同没有什么，我能够间接通过子类的对象调用成员函数不就行了，为啥还要舍本逐末将其赋值到一个父类指针再调用呢？起初学习的时候我也不懂为什么，直到起初我遇到了一个很典型的例子才豁然开朗，这个例子我会在上面讲到。

多态的条件

后面也零零散散地介绍了 C ++ 多态的条件，这里总结一下：

• 须要有继承
• 须要应用父类的指针或援用
• 父类须要有虚函数，子类要重写父类的虚函数

须要上转型是 Java 多态的条件，C++ 次要是通过应用父类的指针或者援用来实现的，也能够认为是一种上转型吧。正是因为应用了父类的指针或者援用，才使得他可能调用子类的虚函数，而不是像上一篇的上转型导致的动态绑定，最终调用的是父类的虚函数。咱们通过以下代码来回顾一下：

class base {
public:
    virtual void do_something() // 有虚函数 {cout << "I'm base class" << endl;}
};

class derived : public base            // 有继承
{
public:
    void do_something() // 子类重写了父类的虚函数 {cout << "I'm derived class" << endl;}
};

void fun1(base &b) // 父类的援用 {b.do_something();
}

void fun2(base *b) // 父类的指针 {b->do_something();
}

void fun3(base b) {b.do_something();
}

int main() {
    derived d;
    fun1(d);    //I'm derived class
    fun2(&d);    //I'm derived class
    fun3(d);    //I'm base class
    return 0;
}

fun1() 和 fun2() 实现的过程都是动静绑定的，即运行时才动静确定要调用哪个函数。那他到底是怎么实现的？

动静绑定的原理

大家还记得虚类的对象是有一个 vptr，多个同类对象的 vptr 指向同一个 vtable。动静绑定就是通过这个 vptr 间接寻址来实现的。尽管子类对象被赋值到了父类的指针，然而对象的 vptr 是没有扭转的，他指向的还是子类的 vtable。所以父类指针去调用某个虚函数的时候，就会去 vtable 外面找函数入口，那找到的天然是子类的函数入口。所以他不是在编译期间就确定的，而是在代码运行到那一行的时候才找到的函数入口。

那为什么只有指针或者援用能力达到这个成果呢？《深度摸索 C ++ 对象模型》这本书对此有这样一个解释：

一个 pointer 或一个 reference 之所以反对多态，是因为它们并不引发内存任何与类型无关的内存委托操作。会受到扭转的，只有它们所指向内存的大小和解释形式而已。

这样读起来有点拗口，简略讲就是指针或者援用的赋值并不会扭转原对象内存里的内容，他只会扭转对内存大小及内容的解释形式。举个简略的例子：我将 int 变量的地址赋值给了 char 型指针，char 型指针才不论原来的变量是什么，他对外只解释一个字节的内容。

同理可知，子类对象的内存内容并没有产生扭转，那么对象的 vptr 还是指向子类的 vtable，所以调用的还是子类的的成员函数。而简略的上转型并不会有这样的成果，他会对内存进行重新分配。

另外说一下，只用 C ++ 有动态绑定这个概念，其余面向对象类的语言都是动静绑定。能够看出 C 语言的常识是很细致入微的。

为什么要应用多态

到此其实多态曾经讲完了，铺垫了这么多前置常识，其实多态就这么一点点。我次要还是想讲讲为什么要应用多态，只有晓得了为什么，能力使咱们在设计代码的时候思考失去如何使用这个知识点。咱们用一个游戏的例子来阐明为什么。

游戏的形容如下：

• 游戏有一个英雄角色，角色属性有生命（hp）和攻击力（ack）
• 英雄能够对怪物进行攻打，同时也会受到怪物的攻打
• 怪物属性有生命（hp）和攻击力（ack）
• 怪物能够对英雄进行攻打，也会受到英雄的攻打
• 现阶段有三种怪物：狼人，僵尸，女巫

咱们先来实现怪物类：

class wolf // 狼人类 {
public:
    wolf(int hp, int ack)
    : hp(hp)
    , ack(ack)
    {}

    bool damage(int dm) {if (this->hp <= 0) return false;
        this->hp -= dm;
        return false;
    }

    bool attack(hero &hr) {return hr.damage(this->ack);
    }

private:
    int hp;
    int ack;
};

class zombie {
public:
    zombie(int hp, int ack)
    : hp(hp)
    , ack(ack)
    {}

    bool damage(int dm) {if (this->hp <= 0) return false;
        this->hp -= dm;
        return false;
    }

    bool attack(hero &hr) {return hr.damage(this->ack);
    }

private:
    int hp;
    int ack;
};

class witch {
public:
    witch(int hp, int ack)
    : hp(hp)
    , ack(ack)
    {}

    bool damage(int dm) {if (this->hp <= 0) return false;
        this->hp -= dm;
        return false;
    }

    bool attack(hero &hr) {return hr.damage(this->ack);
    }

private:
    int hp;
    int ack;
};

而后咱们来实现英雄类：

class hero {
public:
    hero(int hp, int ack)
    : hp(hp)
    , ack(ack)
    {}

    bool damage(int dm) {if (this->hp <= 0) return false;
        this->hp -= dm;
    }

    bool attack(wolf &wf) {return wf.damage(this->ack);
    }

    bool attack(zombie &zb) {return zb.damage(this->ack);
    }

    bool attack(witch &wt) {return wt.damage(this->ack);
    }

private:
    int hp;
    int ack;
};

咱们发现，同样逻辑的 attack() 函数，咱们须要实现三次。如果前期游戏要削减新的怪物，咱们还得持续写 attack() 函数。这其实还是一种面向过程的思维，并不是说写几个类进去就是面向对象了。而且这也齐全不合乎咱们程序猿的编程习惯，咱们程序猿不喜爱反复的货色。欸，这个时候多态就能施展他的作用了。

咱们来定义怪物们的基类：

class monster {
public:
    virtual bool damage(int dm) = 0;
    virtual bool attack(hero &hr) = 0;
};

之前说了，咱们并不关怀这个基类的虚函数具体是怎么实现的，那么咱们就能够将其申明为纯虚类。而后让怪物都继承这个基类，实现下面这两个函数就能够了。这样咱们就能够将 hero 类革新成这样：

class hero {
public:
    hero(int hp, int ack)
    : hp(hp)
    , ack(ack)
    {}

    bool damage(int dm) {if (this->hp <= 0) return false;
        this->hp -= dm;
    }

    bool attack(monster &ms) // 参数批改为 monster 类肯定要用指针或者援用 {return ms.damage(this->ack);
    }

private:
    int hp;
    int ack;
};

这样代码是不是就简洁很多。而且依据多态的性质，不同的怪物会调用其各自的 damage() 函数。当前要是新增怪物，只有继承和实现虚基类就好了，hero 类并不需要进行批改。这就体现了面向对象编程的劣势了，这还只是其中之一。

同理，要是有多种英雄，咱们同样能够形象出一个英雄类的虚基类，而后派生出各式各样的英雄，怪物类也不须要反复写多个 attack() 函数。

有同学还是感觉怪物类的实现还是反复度太高了，这没有体现多态的劣势啊。其实不然，后面说到每个子类都应该重写基类的虚函数，是因为不同的子类都应该有他的特别之处，所以才叫派生嘛。如果子类和子类，或者子类和基类齐全一样那就没有必要继承与派生了。

这里反复度高只是因为代码量小，我只是举了个小小的例子，其实在真正的游戏中不同怪物子类的 attack() 函数和 damage() 函数的外部细节应该是不一样。比方不同的怪物有不同的攻打特效，有不同的受击成果，有不同的技能冷却工夫等等。这些细节都是通过子类去重写基类的虚函数，才得以体现的。

总结

到此为止，我所理解的继承与多态算是总结结束了。会简略地封装几个类并不是面向对象编程，只有彻底了解了封装、继承与多态，面向对象编程才算是入了个门。只有了解了这些，咱们能力开始学习设计模式，能力领悟到设计模式的精华所在。学设计模式倡议大家去看《大话设计模式》这本书，当前有工夫我也会在我的博客里总结一些设计模式。