虚函数与多态

//Polymorphic Bad Guy
//Demonstrates calling member functions dynamically


#include <iostream>


using namespace std;


class Enemy
{
public:
Enemy(int damage = 10);
virtual ~Enemy();
void virtual Attack() const;


protected:
int* m_pDamage;
};


Enemy::Enemy(int damage)
{
m_pDamage = new int(damage);
}


Enemy::~Enemy()               
{
cout << "In Enemy destructor, deleting m_pDamage.\n";
delete m_pDamage;
m_pDamage = 0;
}


void Enemy::Attack() const
{
cout << "An enemy attacks and inflicts " << *m_pDamage << " damage points.";
}  


class Boss : public Enemy
{
public:
Boss(int multiplier = 3); 
virtual ~Boss();
void virtual Attack() const;


protected:
int* m_pMultiplier; 
};


Boss::Boss(int multiplier)
{
m_pMultiplier = new int(multiplier);
}


Boss::~Boss()                 
{
cout << "In Boss destructor, deleting m_pMultiplier.\n";
delete m_pMultiplier;
m_pMultiplier = 0;
} 


void Boss::Attack() const
{
cout << "A boss attacks and inflicts " << (*m_pDamage) * (*m_pMultiplier)
<< " damage points.";
} 


int main()
{
cout << "Calling Attack() on Boss object through pointer to Enemy:\n";
Enemy* pBadGuy = new Boss();
/*用基类指针指向派生类对象。派生类的对象同样属于基类的。BOSS对象也是ENEMY对象。
好处就是，它允许处理对象时无需知晓其确切类型。例如：一个接受Enemy指针的函数能处理Enemy或Boss
对象。该函数无需知晓传递给它的对象的确切类型，并能够根据对象类型产生不同结果，只要派生的成员
函数被声明为虚函数即可。因为Attack()是虚函数，所以调用的是正确版本的成员函数（基于对象的类型），
而不会被指针的类型所限定。
虚函数通过引用和指针产生多态行为。
如果不用虚函数，将得到消息“An enemy attacks and inflicts 10 damage points.”这是由前期捆绑造成
的，成员函数的具体捆绑对象由指定类型决定，在此处是Enemy。如果声明Attack（）虚函数，该函数的调用
取决于运行时指针指向对象的类型，在此处Boss，而不是由指针类型限定。这种多态行为是由后期捆绑造成的。
*/
pBadGuy->Attack();


cout << "\n\nDeleting pointer to Enemy:\n";
delete pBadGuy;
/*构析函数先调用派生类的构析再调用基类的构析，此处基类析构声明为虚类，是因为类中有虚函数成员，
则构析函数也声明为虚函数，使得每个类都能被析构
*/
pBadGuy = 0;


return 0;
}