C++的虚函数和多态

虚函数的概念

在类的定义中，前面有virtual关键字的成员函数就是虚函数，例如：

class base {
    virtual int get();
};

int base::get(){}

• virtual关键字只用在类定义里的函数声明中，写函数体时不用。
• 构造函数和静态成员函数不能是虚函数。

 

什么是多态？

多态的表现形式一

• 派生类的指针可以赋值给基类的指针。
• 通过基类指针调用基类和派生类的同名虚函数时：

1. 若该指针指向一个基类的对象，那么被调用的是基类的虚函数；
2. 若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数；

这种机制就叫做“多态”，例如：

class CBase {
    public:
        virtual void SomeVirtualFunction(){}
};

class CDerived: public CBase {
    public:
        virtual void SomeVirtualFunction(){}
};

int main() {
    CDerived ODerived;
    CBase * p = & ODerived;
    P->SomeVirtualFunction(); //调用哪个虚函数取决于p指向哪种类型的对象
    return 0；
}

 

多态的表现形式二

• 派生类的对象可以赋值给基类的引用。
• 通过基类引用调用基类和派生类的同名虚函数时：

1. 若该引用引用的是一个基类的对象，那么被调用的是基类的虚函数；
2. 若引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。

这种机制也叫做“多态”，例如：

class CBase {
    public:
        virtual void SomeVirtualFunction(){}
};

class CDerived: public CBase {
    public:
        virtual void SomeVirtualFunction(){}
};

int main() {
    CDerived ODerived;
    CBase & r = ODerived;
    r.SomeVirtualFunction(); //调用哪个虚函数取决于p指向哪种类型的对象
    return 0；
}

 

一个关于多态的简单例子：

class A {
    public:
        virtual void Print() {
            cout<<"A::Print"<<endl;
        }
}；

class B: public A {
    public:
        virtual void Print() {
            cout<<"B::Print"<<endl;
        }
}；

class C: public A {
    public:
        virtual void Print() {
            cout<<"C::Print"<<endl;
        }
}；

class D: public A {
    public:
        virtual void Print() {
            cout<<"D::Print"<<endl;
        }
}；

int main(){
    A a;
    B b;
    C c;
    D d;

    A * pa;
    B * pb;
    C * pc;
    D * pd;

    pa->Print(); //输出A::Print
    pa=pb;
    pa->Print(); //输出B::Print
    pa=pc;
    pa->Print(); //输出C::Print
    pa=pd;
    pa->Print(); //输出D::Print
    return 0;
}

 

多态的作用

在面向对象的程序设计中使用多态，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。下面用一个游戏程序开发的例子来说明多态是如何提高程序的可扩充性的。

 

游戏程序开发实例

在某个游戏的开发中，开发者设计了很多怪物，每种怪物都有一个类与之对应，每个怪物都是一个对象。怪物之间能够相互攻击，攻击敌人和被攻击时都有相应的动作，动作是通过对象的成员函数实现的。在某次游戏版本升级中，要增加新的怪物——雷鸟，如何编程才能使升级时的代码改动和增加量最小？

 

游戏开发的基本思路：

• 为每个怪物编写Attack、FightBack和Hurted成员函数。
• Attack函数表现攻击动作，攻击某个怪物，并调用被攻击怪物的Hurted函数，以减少被攻击怪物的生命值，同时也调用被攻击怪物的FightBack函数，遭受被攻击怪物的反击。
• Hurted函数减少自身生命值，并表现受伤动作。
• FightBack成员函数表现反击动作，并调用被反击对象的Hurted成员函数，使被反击对象受伤。

设置怪物基类CCreature，并且使CDragon，CWolf等其他怪物类都从CCreature派生而来。

非多态的实现方法：

class CCreature {
    protected:
        int nPower； //代表攻击力
        int nLifeValve； //代表生命值
};

class CDragon: public CCreature {
    public:
        void Attack(CWolf * pWolf) {
            . . . 表示攻击动作的代码
            pWolf->Hurted(nPower);
            pWolf->FightBack(this);
        }

        void Attack(CGhost * pGhost) {
            . . . 表示攻击动作的代码
            pGhost->Hurted(nPower);
            pGhost->FightBack(this);
        }

        void Hurted(int nPower) {
            . . . 表示受伤动作的代码
            nLifeValve-=nPower;
        }

        void FightBack(CWolf * pWolf) {
            . . . 表示反击动作的代码
            pWolf->Hurted(nPower/2);
        }

        void Fight(CGhost * pGhost) {
            . . . 表示反击动作的代码
            pGhost->Hurted(nPower/2);
        }
};

... //其他的怪物类

 

有n个怪物，每个怪物类里就会有n个与之对应的Attack成员函数，以及n个FightBack成员函数。 如果游戏版本升级，增加了新的怪物雷鸟，则程序改动较大，所有的类都需要增加两个成员函数：

void Attack(CThunderBird * pThunderBird);
void FightBack(CThunder * pThunderBird);

这样在版本升级时，代码的改动量很大，如果使用多态，则会很好地解决这个问题。

 

多态的实现方法：

class CCreature {
    protected:
        int m_nLifeValue, m_nPower;

    protected:
        virtual void Attack(CCreature * pCreature){}
        virtual void Hurted(int nPower){}
        virtual void FightBack(CCreature * pCreature){}
};

class CDragon: public CCreature {
    public:
        void Attack(CCreature * p) {
            . . . 表示攻击动作的代码
            p->Hurted(m_nPower);
            p->FightBack(this); 
        }

        void Hurted(int nPower) {
            . . . 表示受伤动作的代码
            m_nLifeValue-=nPower;
        }

        void FightBack(CCreature * p){
            . . . 表示反击动作的代码
            p->Hurted(m_nPower/2);
    }
};

... //其他的怪物类

 

基类里只有一个Attack成员函数，也只有一个FightBack成员函数，所有的CCreature的派生类也是这样。如果游戏版本升级，增加新的英雄雷鸟，只需要编写相应的新类，不需要在已有的类里专门为新英雄增加以下的代码：

void Attack(CThunderBird * pThunderBird);
void FightBack(CThunderBird * pThunderBird);

原有的类可以原封不动。

 

在主函数内：

CDragon Dragon;
CWolf Wolf;
CGhost Ghost;
CThunderBird Bird;

Dragon.Attack(& Wolf);    (1)
Dragon.Attack(& Ghost);   (2)
Dragon.Attack(& Bird);    (3)

... //其他怪物对象的相应代码

 

根据多态的规则，上面的 (1) (2) (3) 进入到CDragon::Attack函数后，能分别调用：

CWolf::Hurted
CGhost::Hurted
CBird::Hurted

多态的实现原理

“多态”的关键在于通过基类指针或饮用调用一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，只有当运行时才能确定——这叫“动态联编”。

多态实现的关键——虚函数表
每一个虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都放着虚函数表的指针，虚函数表中列出了该类的虚函数地址。

多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。

 

虚析构函数、纯虚函数和抽象类

虚析构函数
通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数。但是，删除一个派生类对象时，应该先调用派生类的析构函数，然后调用基类的析构函数。

解决办法是，把基类的析构函数声明为virtual，派生类的析构函数可以不进行virtual声明。通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数。

一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。

另外注意，不允许以虚函数作为构造函数。

 

实例：

class son {
    public:
        ~son() {
            cout<<“bye from son”<<endl;
        };
};

class grandson: public son {
    public:
        ~grandson() {
            cout<<“bye from grandson”<<endl;
        }
};

int main() {
    son *pson;
    pson=new grandson();
    delete pson; //输出bye from son，没有执行grandson::~grandson()
    return 0;
}

class son {
    public:
        virtual ~son() {
            cout<<“bye from son”<<endl;
        };
};

class grandson: public son {
    public:
        ~grandson() {
            cout<<“bye from grandson”<<endl;
        }
};

int main() {
    son *pson;
    pson=new grandson();
    delete pson; //输出  bye from grandson
                 //      bye from son    
    return 0;
}

 

纯虚函数和抽象类

纯虚函数，是没有函数题体的虚函数，如下所示：

class A {
    private: 
        int a;
    
    public:
        virtual void Print()=0; //纯虚函数
        void fun() {
            cout<<“fun”;
        }
};

 

包含纯虚函数的类叫做抽象类：

• 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象。
• 抽象类的指针和引用可以指向由抽象类派生出来的类的对象。

在抽象类的成员函数内部可以调用纯虚函数，但是在构造函数或析构函数内部不能调用纯虚函数。

如果一个类从抽象类派生而来，那么当且仅当它实现了基类中那个所有的纯虚函数，它才能成为非抽象类。
 

 

 

 

参考自：中国大学慕课，程序设计与算法（三） C++面向对象程序设计，北京大学，郭炜