C++:多态性

C++:多态性 

 转自：http://oucmsc.blog.163.com/blog/static/12634032820111133812350/

封装、继承和多态性（polymorphism）是C++ OOP的三大支柱。多态意味着函数将根据调用它的对象类型不同而产生不同的结果。

从系统的角度，多态性分为两类：静态多态性和动态多态性。静态多态性是通过函数重载实现的，运算符的重载是函数重载的特殊形式，在程序编译时就能决定调用的是那个函数，因此静态多态性又称为编译时的多态性。动态多态性是程序运行过程中才动态地确定操作所针对的对象，又称为运行时的多态性。

此处说的是动态多态性的实现；在C++中动态多态性的实现是通过虚函数（virtual function）实现的。

虚函数的作用：允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

通过实例很容易说明多态的本质（下述代码来自于《C++游戏编程入门教程》

//Virtual Boss
//介绍虚函数

#include <iostream>
using namespace std;
class Enemy
{
public:
    Enemy(int damage = 10)
    { m_pDamage = new int(damage); }
    virtual ~Enemy()  //定义虚拟析构函数，这儿有必要性，见下
   {
        cout << "m_pDamagedeleted\n";
        delete m_pDamage;
    }
    void Taunt() const
    { cout << "The enemy sayshe will fight you.\n"; } 
    void virtual VTaunt() const
    { cout << "The enemy sayshe will fight you.\n"; }

protected:
    int* m_pDamage;
};

class Boss : public Enemy
{
public:
    Boss(int multiplier = 3)
    { m_pDamageMultiplier = new int(multiplier);}  
    virtual ~Boss()
    {
        cout << "m_pDamageMultiplierdeleted\n";
        delete m_pDamageMultiplier;
    } 
    void Taunt() const
    { cout << "The boss sayshe will end your pitiful existence.\n"; } 

    void virtual VTaunt() const
    { cout << "The boss sayshe will end your pitiful existence.\n";}
   
protected:
    int* m_pDamageMultiplier;
};

int main()
{
    cout << "Pointer to Enemythat points to a Boss object:\n";
    Enemy* pBadGuy = new Boss();
    pBadGuy->Taunt();
    pBadGuy->VTaunt();
  
    cout << "\nDeletingpointer to Enemy:\n";
    delete pBadGuy;
    pBadGuy = 0;

    return 0;
}

1.虚成员函数

派生类的对象也是基类的一员，所以可以用指向基类的指针来指向派生类的对象。在main函数就是这样做的，它在堆上实例化一个Boss对象并创建一个Enemy指针来指向它：

Enemy* pBadGuy = new Boss();

至于为什么这么做，是为了说明多态性而故意这样做的。

现在我们对比下面两行代码的输出：

pBadGuy->Taunt();
pBadGuy->VTaunt();

第一行代码输出的是：Theenemy says he will fight you.

第二行代码输出的是：Theboss says he will end your pitiful existence.

分析：从调用上我们可以看出第一行代码调用的是基类的函数，而第二行代码调用的是派生类的函数。为什么都是指向基类的指针，调用的结果却不如你所想象的那样，都调用的是基类的成员函数呢？

过程：

第一行语句执行过程：本来，基类指针是用来指向基类对象的，如果用它指向派生类对象，则进行指针类型转换 ——将派生类对象的指针先转化为基类的指针，所以基类的指针指向的是派生类对象中的基类部分。

第二行语句执行过程：虚函数可以突破上述限制，在派生类的基类部分中，派生类的虚函数取代了基类的虚函数，因此在使用基类指针指向派生类对象后，调用虚函数时就调用了派生类的虚函数。

原因：第一行编译系统采用的是“前期绑定”，它根据指针类型来绑定确切的成员函数。（大部分或者一般情况下，我们使用的都是这种类型；）；第二行，通过“虚函数”实现灵活的“后期绑定”，根据指向的对象类型调用成员函数，虚函数允许多态行为。

 

虚函数的使用方法：

1）要想创建一个虚函数，只需在声明函数的前面加上关键字virtual即可：

 voidvirtual VTaunt() const
    { cout << "The enemy sayshe will fight you.\n"; }

提示：C++规定，将一个成员函数定义为虚拟的后，其派生类中的同名函数都是虚函数。这意味着在派生类中可以不在相应的虚函数前使用virtual关键字，但是强烈推荐继续使用virtual关键字，可以提醒自己这个函数是虚拟的。

2）在派生类中重新定义此函数时，要求函数名、函数类型、函数参数个数和类型都要全部和基类虚函数相同，并根据派生类的需要重新定义函数体。

3）定义一个指向基类对象的指针变量，并使它指向同一类族的某个对象。

4）通过指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。

通过虚函数和指向基类对象的指针变量的配合使用，就能方便的调用同一类族不同类的同名函数，只要先用基类的指针指向即可。如果指针不断地指向同一类族不同类的对象，就能不断地调用这些对象中的同名函数。

2.虚析构函数

在使用指向基类的指针来指向派生类的一个对象时，存在一个潜在的问题！在使用delete删除这个指针时，将只为这个对象调用基类的析构函数，如果此时的派生类中有需要释放的内存（如上面的Boss中就再类中new了一段内存），则会发生内存泄露问题。

解决方法：将析构函数也定义为虚拟的！这样在用delete删除这个一个指针所指向的对象时，先调用指针所指向对象（派生类对象）对应的析构函数而不是该指针对象的析构函数，进而它导致基类的析构函数被调用，使各个类都有机会清理自己。

如上面的代码所示，

基类中的析构函数：

 virtual~Enemy() //定义虚拟析构函数，这儿有必要性，见下
   {
        cout << "m_pDamagedeleted\n";
        delete m_pDamage;
    }

派生类中的析构函数：

virtual ~Boss()
    {
        cout << "m_pDamageMultiplierdeleted\n";
        delete m_pDamageMultiplier;
    }