亲宝软件园·资讯

展开

C++ 一篇搞懂多态的实现原理

小林coding 人气:1

虚函数和多态

01 虚函数

  • 在类的定义中，前面有 virtual 关键字的成员函数称为虚函数；
  • virtual 关键字只用在类定义里的函数声明中，写函数体时不用。
class Base 
{
    virtual int Fun() ; // 虚函数
};

int Base::Fun() // virtual 字段不用在函数体时定义
{ }

02 多态的表现形式一

  • 「派生类的指针」可以赋给「基类指针」；
  • 通过基类指针调用基类和派生类中的同名「虚函数」时:
    1. 若该指针指向一个基类的对象，那么被调用是
      基类的虚函数；
    2. 若该指针指向一个派生类的对象，那么被调用
      的是派生类的虚函数。

这种机制就叫做“多态”，说白点就是调用哪个虚函数，取决于指针对象指向哪种类型的对象。

// 基类
class CFather 
{
public:
    virtual void Fun() { } // 虚函数
};

// 派生类
class CSon : public CFather 
{ 
public :
    virtual void Fun() { }
};

int main() 
{
    CSon son;
    CFather *p = &son;
    p->Fun(); //调用哪个虚函数取决于 p 指向哪种类型的对象
    return 0;
}

上例子中的 p 指针对象指向的是 CSon 类对象，所以 p->Fun() 调用的是 CSon 类里的 Fun 成员函数。

03 多态的表现形式二

  • 派生类的对象可以赋给基类「引用」
  • 通过基类引用调用基类和派生类中的同名「虚函数」时:
    1. 若该引用引用的是一个基类的对象，那么被调
      用是基类的虚函数；
    2. 若该引用引用的是一个派生类的对象，那么被
      调用的是派生类的虚函数。

这种机制也叫做“多态”，说白点就是调用哪个虚函数，取决于引用的对象是哪种类型的对象。

// 基类
class CFather 
{
public:
    virtual void Fun() { } // 虚函数
};

// 派生类
class CSon : public CFather 
{ 
public :
    virtual void Fun() { }
};

int main() 
{
    CSon son;
    CFather &r = son;
    r.Fun(); //调用哪个虚函数取决于 r 引用哪种类型的对象
    return 0;
}
}

上例子中的 r 引用的对象是 CSon 类对象，所以 r.Fun() 调用的是 CSon 类里的 Fun 成员函数。

04 多态的简单示例

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

// 继承A类
class B: public A 
{
public :
    virtual void Print() { cout << "B::Print" <<endl; }
};

// 继承A类
class D: public A 
{
public:
    virtual void Print() { cout << "D::Print" << endl ; }
};

// 继承B类
class E: public B 
{
    virtual void Print() { cout << "E::Print" << endl ; }
};

A类、B类、E类、D类的关系如下图：

int main() 
{
    A a; B b; E e; D d;
    
    A * pa = &a; 
    B * pb = &b;
    D * pd = &d; 
    E * pe = &e;
    
    pa->Print();  // a.Print()被调用，输出：A::Print
    
    pa = pb;
    pa -> Print(); // b.Print()被调用，输出：B::Print
    
    pa = pd;
    pa -> Print(); // d.Print()被调用，输出：D::Print
    
    pa = pe;
    pa -> Print(); // e.Print()被调用，输出：E::Print
    
    return 0;
}

05 多态作用

在面向对象的程序设计中使用「多态」，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。

LOL 英雄联盟游戏例子

下面我们用设计 LOL 英雄联盟游戏的英雄的例子，说明多态为什么可以在修改或增加功能的时候，可以较少的改动代码。

LOL 英雄联盟是 5v5 竞技游戏，游戏中有很多英雄，每种英雄都有一个「类」与之对应，每个英雄就是一个「对象」。

英雄之间能够互相攻击，攻击敌人和被攻击时都有相应的动作，动作是通过对象的成员函数实现的。

下面挑了五个英雄：

  • 探险家 CEzreal
  • 盖楼 CGaren
  • 盲僧 CLeesin
  • 无极剑圣 CYi
  • 瑞兹 CRyze

基本思路：

  1. 为每个英雄类编写 Attack、FightBack 和 Hurted 成员函数。
  • Attack 函数表示攻击动作；
  • FightBack 函数表示反击动作；
  • Hurted 函数表示减少自身生命值，并表现受伤动作。
  1. 设置基类CHero，每个英雄类都继承此基类

02 非多态的实现方法

// 基类
class CHero 
{
protected:  
    int m_nPower ; //代表攻击力
    int m_nLifeValue ; //代表生命值
};


// 无极剑圣类
class CYi : public CHero 
{
public:
    // 攻击盖伦的攻击函数
    void Attack(CGaren * pGaren) 
    {
        .... // 表现攻击动作的代码
        pGaren->Hurted(m_nPower);
        pGaren->FightBack(this);
    }

    // 攻击瑞兹的攻击函数
    void Attack(CRyze * pRyze) 
    {
        .... // 表现攻击动作的代码
        pRyze->Hurted(m_nPower);
        pRyze->FightBack( this);
    }
    
    // 减少自身生命值
    void Hurted(int nPower) 
    {
        ... // 表现受伤动作的代码
        m_nLifeValue -= nPower;
    }
    
    // 反击盖伦的反击函数
    void FightBack(CGaren * pGaren) 
    {
        ...．// 表现反击动作的代码
        pGaren->Hurted(m_nPower/2);
    }
    
    // 反击瑞兹的反击函数
    void FightBack(CRyze * pRyze) 
    {
        ...．// 表现反击动作的代码
        pRyze->Hurted(m_nPower/2);
    }
};

有 n 种英雄，CYi 类中就会有 n 个 Attack 成员函数，以及 n 个 FightBack
成员函数。对于其他类也如此。

如果游戏版本升级，增加了新的英雄寒冰艾希 CAshe，则程序改动较大。所有的类都需要增加两个成员函数:

void Attack(CAshe * pAshe);
void FightBack(CAshe * pAshe);

这样工作量是非常大的！！非常的不人性，所以这种设计方式是非常的不好！

03 多态的实现方式

用多态的方式去实现，就能得知多态的优势了，那么上面的栗子改成多态的方式如下：

// 基类
class CHero 
{
public:
    virtual void Attack(CHero *pHero){}
    virtual voidFightBack(CHero *pHero){}
    virtual void Hurted(int nPower){}

protected:  
    int m_nPower ; //代表攻击力
    int m_nLifeValue ; //代表生命值
};

// 派生类 CYi:
class CYi : public CHero {
public:
    // 攻击函数
    void Attack(CHero * pHero) 
    {
        .... // 表现攻击动作的代码
        pHero->Hurted(m_nPower); // 多态
        pHero->FightBack(this);  // 多态
    }
    
    // 减少自身生命值
    void Hurted(int nPower) 
    {
        ... // 表现受伤动作的代码
        m_nLifeValue -= nPower;
    }
    
    // 反击函数
    void FightBack(CHero * pHero) 
    {
        ...．// 表现反击动作的代码
        pHero->Hurted(m_nPower/2); // 多态
    }
};

如果增加了新的英雄寒冰艾希 CAshe，只需要编写新类CAshe，不再需要在已有的类里专门为新英雄增加：

void Attack( CAshe * pAshe) ;
void FightBack(CAshe * pAshe) ;

所以已有的类可以原封不动，那么使用多态的特性新增英雄的时候，可见改动量是非常少的。

多态使用方式：

void CYi::Attack(CHero * pHero) 
{
    pHero->Hurted(m_nPower); // 多态
    pHero->FightBack(this);  // 多态
}

CYi yi; 
CGaren garen; 
CLeesin leesin; 
CEzreal ezreal;

yi.Attack( &garen );  //(1)
yi.Attack( &leesin ); //(2)
yi.Attack( &ezreal ); //(3)

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

CGaren::Hurted
CLeesin::Hurted
CEzreal::Hurted

多态的又一例子

出一道题考考大家，看大家是否理解到了多态的特性，下面的代码，pBase->fun1()输出结果是什么呢？

class Base 
{
public:
    void fun1() 
    { 
        fun2(); 
    }
    
    virtual void fun2()  // 虚函数
    { 
        cout << "Base::fun2()" << endl; 
    }
};

class Derived : public Base 
{
public:
    virtual void fun2()  // 虚函数
    { 
        cout << "Derived:fun2()" << endl; 
    }
};

int main() 
{
    Derived d;
    Base * pBase = & d;
    pBase->fun1();
    return 0;
}

是不是大家觉得 pBase 指针对象虽然指向的是派生类对象，但是派生类里没有 fun1 成员函数，则就调用基类的 fun1 成员函数，Base::fun1() 里又会调用基类的 fun2 成员函数，所以输出结果是Base::fun2() ？

假设我把上面的代码转换一下， 大家还觉得输出的是 Base::fun2() 吗？

class Base 
{
public:
    void fun1() 
    { 
        this->fun2();  // this是基类指针，fun2是虚函数，所以是多态
    }
}

this 指针的作用就是指向成员函数所作用的对象， 所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。

pBase 指针对象指向的是派生类对象，派生类里没有 fun1 成员函数，所以就会调用基类的 fun1 成员函数，在Base::fun1() 成员函数体里执行 this->fun2() 时，实际上指向的是派生类对象的 fun2 成员函数。

所以正确的输出结果是：

Derived:fun2()

所以我们需要注意：

在非构造函数，非析构函数的成员函数中调用「虚函数」，是多态!!!

构造函数和析构函数中存在多态吗？

在构造函数和析构函数中调用「虚函数」，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

我们看如下的代码例子，来说明：

// 基类
class CFather 
{
public:
    virtual void hello() // 虚函数
    {
        cout<<"hello from father"<<endl; 
    }
    
    virtual void bye() // 虚函数
    {
        cout<<"bye from father"<<endl; 
    }
};

// 派生类
class CSon : public CFather
{ 
public:
    CSon() // 构造函数
    { 
        hello(); 
    }
    
    ~CSon()  // 析构函数
    { 
        bye();
    }

    virtual void hello() // 虚函数
    { 
        cout<<"hello from son"<<endl;
    }
};

int main()
{
    CSon son;
    CFather *pfather;
    pfather = & son;
    pfather->hello(); //多态
    return 0;
}

输出结果：

hello from son  // 构造son对象时执行的构造函数
hello from son  // 多态
bye from father // son对象析构时，由于CSon类没有bye成员函数，所以调用了基类的bye成员函数

多态的实现原理

「多态」的关键在于通过基类指针或引用调用一个虚函数时，编译时不能确定到底调用的是基类还是派生类的函数，运行时才能确定。

我们用 sizeof 来运算有有虚函数的类和没虚函数的类的大小，会是什么结果呢？

class A 
{
public:
    int i;
    virtual void Print() { } // 虚函数
};

class B
{
public:
    int n;
    void Print() { } 
};

int main() 
{
    cout << sizeof(A) << ","<< sizeof(B);
    return 0;
}

在64位机子，执行的结果：

16,4

从上面的结果，可以发现有虚函数的类，多出了 8 个字节，在 64 位机子上指针类型大小正好是 8 个字节，这多出 8 个字节的指针有什么作用呢？

01 虚函数表

每一个有「虚函数」的类（或有虚函数的类的派生类）都有一个「虚函数表」，该类的任何对象中都放着虚函数表的指针。「虚函数表」中列出了该类的「虚函数」地址。

多出来的 8 个字节就是用来放「虚函数表」的地址。

// 基类
class Base 
{
public:
    int i;
    virtual void Print() { } // 虚函数
};

// 派生类
class Derived : public Base
{
public:
    int n;
    virtual void Print() { } // 虚函数
};

上面 Derived 类继承了 Base类，两个类都有「虚函数」，那么它「虚函数表」的形式可以理解成下图：

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

02 证明虚函数表指针的作用

在上面我们用 sizeof 运算符计算了有虚函数的类的大小，发现是多出了 8 字节大小（64位系统），这多出来的 8 个字节就是指向「虚函数表的指针」。「虚函数表」中列出了该类的「虚函数」地址。

下面用代码的例子，来证明「虚函数表指针」的作用：

// 基类
class A 
{
public: 
    virtual void Func()  // 虚函数
    { 
        cout << "A::Func" << endl; 
    }
};

// 派生类
class B : public A 
{
public: 
    virtual void Func()  // 虚函数
    { 
        cout << "B::Func" << endl;
    }
};

int main() 
{
    A a;
    
    A * pa = new B();
    pa->Func(); // 多态
    
    // 64位程序指针为8字节
    int * p1 = (int *) & a;
    int * p2 = (int *) pa;
    
    * p2 = * p1;
    pa->Func();
    
    return 0;
}

输出结果：

B::Func
A::Func
  • 第 25-26 行代码中的 pa 指针指向的是 B 类对象，所以 pa->Func() 调用的是 B 类对象的虚函数 Func()，输出内容是 B::Func ；
  • 第 29-30 行代码的目的是把 A 类的头 8 个字节的「虚函数表指针」存放到 p1 指针和把 B 类的头 8 个字节的「虚函数表指针」存放到 p2 指针；
  • 第 32 行代码目的是把 A 类的「虚函数表指针」 赋值给 B 类的「虚函数表指针」，所以相当于把 B 类的「虚函数表指针」 替换 成了 A 类的「虚函数表指针」；
  • 由于第 32 行的作用，把 B 类的「虚函数表指针」 替换 成了 A 类的「虚函数表指针」，所以第 33 行调用的是 A 类的虚函数 Func()，输出内容是 A::Func

通过上述的代码和讲解，可以有效的证明了「虚函数表的指针」的作用，「虚函数表的指针」指向的是「虚函数表」，「虚函数表」里存放的是类里的「虚函数」地址，那么在调用过程中，就能实现多态的特性。

虚析构函数

析构函数是在删除对象或退出程序的时候，自动调用的函数，其目的是做一些资源释放。

那么在多态的情景下，通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数，这就会存在派生类对象的析构函数没有调用到，存在资源泄露的情况。

看如下的例子：

// 基类
class A 
{
public: 
    A()  // 构造函数
    {
        cout << "construct A" << endl;
    }
    
    ~A() // 析构函数
    {
        cout << "Destructor A" << endl;
    }
};

// 派生类
class B : public A 
{
public: 
    B()  // 构造函数
    {
        cout << "construct B" << endl;
    }
    
    ~B()// 析构函数
    {
        cout << "Destructor B" << endl;
    }
};

int main() 
{
    A *pa = new B();
    delete pa;
    
    return 0;
}

输出结果：

construct A
construct B
Destructor A

从上面的输出结果可以看到，在删除 pa指针对象时，B 类的析构函数没有被调用。

解决办法：把基类的析构函数声明为virtual

  • 派生类的析构函数可以 virtual 不进行声明；
  • 通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数，还是遵循「先构造，后虚构」的规则。

将上述的代码中的基类的析构函数，定义成「虚析构函数」：

// 基类
class A 
{
public: 
    A()  
    {
        cout << "construct A" << endl;
    }
    
    virtual ~A() // 虚析构函数
    {
        cout << "Destructor A" << endl;
    }
};

输出结果：

construct A
construct B
Destructor B
Destructor A

所以要养成好习惯:

  • 一个类如果定义了虚函数，则应该将析构函数也定义成虚函数;
  • 或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。
  • 注意：不允许构造函数不能定义成虚构造函数。

纯虚函数和抽象类

纯虚函数： 没有函数体的虚函数

class A 
{

public:
    virtual void Print( ) = 0 ; //纯虚函数
private: 
    int a;
};

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

  • 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象
  • 抽象类的指针和引用可以指向由抽象类派生出来的类的对象
A a;         // 错，A 是抽象类，不能创建对象
A * pa ;     // ok,可以定义抽象类的指针和引用
pa = new A ; // 错误, A 是抽象类，不能创建对象

推荐阅读：

C++ this指针的理解和作用

C++ 一篇搞懂继承的常见特性

C++ 赋值运算符'='的重载（浅拷贝、深拷贝）

C++ 手把手教你实现可变长的数组

加载全部内容
相关教程
猜你喜欢
用户评论