C++ 奥特曼打怪兽之多态（系列5）

题目描述

重新组织和修改前面“类的继承”的代码，利用多态实现以下内容，使得下面的main函数能正确执行并输出相关信息。

对怪兽类进行了扩充和修改：

Monster类：

1.添加lose方法，当被奥特曼打败后，输出：Boss!Help!

2.修改display方法，以以下格式输出怪兽状态(??代表具体数值)：

怪兽状态(rank=?? hp=?? damage=?? exp=?? money=??)

Boss类：

1.修改绝招(XP)方法，在原来的基础上添加代码，使得每次调用此方法时，输出：

XP*****

2.添加lose方法，当被奥特曼打败后，输出：

I’ll be back!

3.修改display方法，以以下格式输出怪兽状态(??代表具体数值)：

Boss怪兽状态(rank=?? hp=?? damage=?? exp=?? money=??)

请自行将部分函数设置成虚函数，以实现多态。

---

谁也不知道迎接奥特曼的下一个怪兽是小怪兽还是Boss。边打边看，且打且珍惜吧。

int main(){

//输入奥特曼的等级值，利用等级值，声明一个奥特曼对象并显示奥特曼对象初始状态。

int ograd;   cin>>ograd;

Ultraman uobj(ograd);

int t;   cin>>t;//输入要打的怪兽个数数

while(t--&&uobj.getHp()>10){//只要奥特曼没死也没逃跑，就继续与怪兽的战斗

     uobj.display();  

     Monster* p; 

     char c=0;

     while(1){

         cin>>c;

         if(c=='B') {p=new Boss();break;}

         else if(c=='M') {int r;cin>>r;p=new Monster(r);break;}  

         else cout<<"请重新输入怪兽类型"<display();        

     //设置战斗标志flag为true，启动战斗循环，具体如下：

     int flag=1;

     while(flag) //当战斗未结束就继续

     {   uobj.attack(*p);//奥特曼攻击1次            

         if (p->getHp()>0)  //怪兽没死

         {   p->fightback(uobj);//怪兽反击1次

              if (uobj.getHp()>10)      //奥特曼生命值大于点，不逃跑

                  uobj.restore();//奥特曼回血，在方法中判断是否需要加血

              else {   //奥特曼逃跑，并输出"lose"并回车

                  uobj.escape();

                  cout<<"lose"<lose();//输出怪兽战败信息

              flag=0;//停止战斗

         }

     }

}

return 0;

 }

输入
第1行输入奥特曼等级

第2行输入怪兽个数

对于每个怪兽，首先输入怪兽类别（‘M’或‘B’）

如果是小怪兽，接着下一行输入怪兽等级

输出
输出战斗过程。具体参考Sample Output

样例输入
30 3 M 5 M 5 B
样例输出
奥特曼状态(rank=30 hp=300 damage=90 exp=0 money=300)
怪兽状态(rank=5 hp=100 damage=10 exp=50 money=50)
win
Boss!Help!
奥特曼状态(rank=30 hp=295 damage=90 exp=50 money=350)
怪兽状态(rank=5 hp=100 damage=10 exp=50 money=50)
win
Boss!Help!
奥特曼状态(rank=30 hp=290 damage=90 exp=100 money=400)
Boss怪兽状态(rank=10 hp=300 damage=50 exp=1000 money=1001)
win
I’ll be back!

#include
#include 
using namespace std;
class Monster;		//前置声明Monster类，因为Ultraman类中用到了 
class Boss;			//同理 
class Ultraman {
	private:
		int rank; // 等级
		int hp;	 	//生命值
		int damage;	//攻击力
		int exp;	//经验
		int money;	//钱
	public:
		Ultraman(int);
		void display();	//展示实力
		void escape();	//逃跑
		void attacked(int);	//被攻击		
		void attack(Monster&);	//攻击
		void restore();	//补血
		void win(Monster);		//胜利
		void upgrade();	 //升级
		void die();
		int get_rank();
		int get_hp();
		int get_damage();
		int get_exp();
		int get_money();
};
class Monster {
	protected:
		int rank; // 等级
		int hp;	 	//生命值
		int damage;	//攻击力
		int exp;	//经验
		int money;	//钱
	public:
		Monster(int);
		Monster() {	};
		void attacked(int);	//被攻击
		void fightback(Ultraman&);	//攻击	
		int get_rank();
		int get_hp();
		int get_exp();
		int get_money();
		int get_damage();
		virtual	void lose();
		virtual void display();
};
class Boss:public Monster {
	private:
		int count;  //大招怒气，即被打次数 
	public:
		Boss();
		void fightback(Ultraman&);
		void attacked(int);
		int get_count() {
			return count;
		}
		virtual void lose();
		void XP(Ultraman&); 
		virtual void display();
};
Ultraman::Ultraman(int a) {
	rank=a;
	hp=10*a;
	exp=0;
	damage=3*a;
	money=10*a;
}
int Ultraman::get_rank() {
	return rank;
}
int Ultraman::get_hp() {
	return hp;
}
int Ultraman::get_damage() {
	return damage;
}
int Ultraman::get_exp() {
	return	exp;
}
int Ultraman::get_money() {
	return money;
}
//当生命不超过10点时，奥特曼将逃跑，逃跑将损失所有金钱
void Ultraman::escape() {
	money=0;
}
void Ultraman::win(Monster Viga) {
	exp+=Viga.get_exp();
	money+=Viga.get_money();
}
void Ultraman::attack(Monster& Viga) {		//奥特曼攻击相当于怪兽被攻击，经典《相对论》
	Viga.attacked(damage);
}
void Ultraman::attacked(int monster_damage) {		//被打就要扣血 
	hp-=monster_damage/2;
}
void Ultraman::upgrade() {
	while(exp>=10*rank) {
		exp-=10*rank;
		rank++;
		hp=rank*10;
		damage=rank*3;
	}
}
void Ultraman::restore() {
	while(hp<5*rank&&money>=10) {
		hp++;
		money-=10;
	}
}
void Ultraman::display() {
	cout<<"奥特曼状态(rank="<<rank;
	cout<<" hp="<<hp;
	cout<<" damage="<<damage;
	cout<<" exp="<<exp;
	cout<<" money="<<money<<")"<<endl;
}
void Ultraman::die() {
	money=0;
	cout<<"lose"<<endl;
}
Monster::Monster(int a) {
	rank=a;
	hp=20*a;
	damage=a*2;
	money=10*a;
	exp=a*10;
}
int Monster::get_rank() {
	return rank;
}
int Monster::get_hp() {
	return hp;
}
int Monster::get_damage() {
	return damage;
}
int Monster::get_exp() {
	return	exp;
}
int Monster::get_money() {
	return money;
}
void Monster::fightback(Ultraman &Tiga) { 	 	//怪兽攻击相当于奥特曼被攻击，经典《相对论》 
	Tiga.attacked(damage);
}
void Monster::attacked(int ultraman_damage) {	//被攻击就扣血 
	hp-=ultraman_damage;
}
void  Monster::lose(){
	cout<<"Boss!Help!"<<endl;
}
void Monster::display(){
	cout<<"怪兽状态(rank="<<rank;
	cout<<" hp="<<hp;
	cout<<" damage="<<damage;
	cout<<" exp="<<exp;
	cout<<" money="<<money<<")"<<endl;
}
Boss::Boss() {
	count=0;
	rank=10;
	hp=300;
	exp=1000;
	damage=50;
	money=1001;
}
void Boss::attacked(int ultraman_damage) {	//被攻击就扣血 
	hp-=ultraman_damage;
	count++;   //攒大招怒气 
}
void Boss::fightback(Ultraman &Tiga){
	if(count%5!=0)		//攒满五次怒气开大 
		Tiga.attacked(damage);
	else{
		XP(Tiga);
	}
		
}
void Boss::display(){
	cout<<"Boss怪兽状态(rank="<<rank;
	cout<<" hp="<<hp;
	cout<<" damage="<<damage;
	cout<<" exp="<<exp;
	cout<<" money="<<money<<")"<<endl;
}
void Boss::lose(){
	cout<<"I'll be back!"<<endl;
}
void Boss::XP(Ultraman &Viga){
	for(int i=0;i<3;i++)
	Viga.attacked(damage);  //大招攻击三次 
	cout<<"XP*****"<<endl; //用大招名字要念出来 
}
int main(){
    //输入奥特曼的等级值，利用等级值，声明一个奥特曼对象并显示奥特曼对象初始状态。
    int ograd;   
	cin>>ograd;
    Ultraman uobj(ograd);
    int t;   
	cin>>t;//输入要打的怪兽个数数
    while(t--&&uobj.get_hp()>10){//只要奥特曼没死也没逃跑，就继续与怪兽的战斗
         uobj.display();  
         Monster* p; 
         char c=0;
         while(1){
             cin>>c;
             if(c=='B') {p=new Boss();break;}
             else if(c=='M') {int r;cin>>r;p=new Monster(r);break;}  
             else cout<<"请重新输入怪兽类型"<<endl;
         }
         p->display();        
         //设置战斗标志flag为true，启动战斗循环，具体如下：
         int flag=1;
         while(flag) //当战斗未结束就继续
         {   uobj.attack(*p);//奥特曼攻击1次            
             if (p->get_hp()>0)  //怪兽没死
             {   p->fightback(uobj);//怪兽反击1次
                  if (uobj.get_hp()>10)      //奥特曼生命值大于点，不逃跑
                      uobj.restore();//奥特曼回血，在方法中判断是否需要加血
                  else {   //奥特曼逃跑，并输出"lose"并回车
                      uobj.escape();
                      cout<<"lose"<<endl;                   
                      uobj.display();//输出奥特曼状态       
                      flag=0;//停止战斗                 
                  }
             }
             else //怪兽死了
             {   uobj.win(*p);     //奥特曼胜利，并输出"win"并回车
                  cout<<"win"<<endl;
                  uobj.upgrade();//奥特曼升级
				  p->lose();//输出怪兽战败信息
                  flag=0;//停止战斗
             }
         }
    }
    return 0;
}