消息队列
虚函数和多态
01 虚函数
- 在类的定义中,前面有
virtual
关键字的成员函数称为虚函数; virtual
关键字只用在类定义里的函数声明中,写函数体时不用。
class Base
{
virtual int Fun() ; // 虚函数
};
int Base::Fun() // virtual 字段不用在函数体时定义
{ }
02 多态的表现形式一
- 「派生类的指针」可以赋给「基类指针」;
- 通过基类指针调用基类和派生类中的同名「虚函数」时:
- 若该指针指向一个基类的对象,那么被调用是
基类的虚函数; - 若该指针指向一个派生类的对象,那么被调用
的是派生类的虚函数。
- 若该指针指向一个基类的对象,那么被调用是
这种机制就叫做“多态”,说白点就是调用哪个虚函数,取决于指针对象指向哪种类型的对象。
// 基类
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 多态的表现形式二
- 派生类的对象可以赋给基类「引用」
- 通过基类引用调用基类和派生类中的同名「虚函数」时:
- 若该引用引用的是一个基类的对象,那么被调
用是基类的虚函数; - 若该引用引用的是一个派生类的对象,那么被
调用的是派生类的虚函数。
- 若该引用引用的是一个基类的对象,那么被调
这种机制也叫做“多态”,说白点就是调用哪个虚函数,取决于引用的对象是哪种类型的对象。
// 基类
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
基本思路:
- 为每个英雄类编写
Attack
、FightBack
和Hurted
成员函数。
Attack
函数表示攻击动作;FightBack
函数表示反击动作;Hurted
函数表示减少自身生命值,并表现受伤动作。
- 设置基类
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 是抽象类,不能创建对象
推荐阅读:
Android 事件传递机制