C++ 奥特曼打怪兽之运算符重载（系列6）

题目描述

在奥特曼打怪兽的过程中，会有各种魔法袋，奥特曼可以捡起这些魔法袋，对自己施加不同的魔法。魔法袋的种类和功能描述如下：

1． “好事成双”魔法袋(重载+
+)：使自己的等级翻倍，生命值恢复满血，为翻倍后等级的10倍，攻击力提升为翻倍后等级的3倍，经验和钱财翻倍。

2． “祸不单行”魔法袋(重载– –)：使自己的生命值、攻击力、经验和钱财缩减为原来的一半。

3． “吸星大法”魔法袋(重载 <)：所当前所打怪兽等级小于奥特曼，则奥特曼的生命值、攻击力、经验和钱财将增加怪兽相应属性的一半。

4． “有缘相会”魔法袋(重载 ==)：所当前所打怪兽等级等于奥特曼，则奥特曼的生命值、攻击力、经验和钱财将增加怪兽相应属性的取值。

以成员函数方式为奥特曼重载以上方法。

另外以友元方式为奥特曼重载运算符<<，使它能够支持与普通类型数据一样的输出方式。

重新组织和修改前面实验的代码，利用运算符重载实现以下内容，使得下面的main函数能正确执行并输出相关信息。

---

int main(){

int ograd;   cin>>ograd;//输入奥特曼的等级值，利用等级值，声明一个奥特曼对象。

Ultraman uobj(ograd);

cout<>t;//输入测试次数

while(t--){ 

     char c=0;

     while(1){

         cin>>c;//输入要使用的魔法袋，G代表好事成双，B代表祸不单行，X代表吸星大法，Y代表有缘相会

         if(c=='G')   {

              cout<<"****好事成双****"<>r;//输入怪兽的等级值，利用等级值，声明一个怪兽对象并显示对象初始状态。

              Monster mobj(r); 

             mobj.display();

              cout<<"****吸星大法****"<>r;//输入怪兽的等级值，利用等级值，声明一个怪兽对象并显示对象初始状态。

              Monster mobj(r); 

              mobj.display();

              cout<<"****有缘相会****"<

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

第2行输入测试次数

对于每次测试，输入魔法袋类别（G代表好事成双，B代表祸不单行，X代表吸星大法，Y代表有缘相会）

如果是后两种魔法袋，接着下一行输入怪兽等级

输出 参考Sample Output

样例输入
10 4 G B X 5 Y 20
样例输出
奥特曼状态(rank=10 hp=100 damage=30 exp=0 money=100)
好事成双
成功翻倍
奥特曼状态(rank=20 hp=200 damage=60 exp=0 money=200)
祸不单行
不幸减半
奥特曼状态(rank=20 hp=100 damage=30 exp=0 money=100)
怪兽状态(rank=5 hp=100 damage=10 exp=50 money=50)
吸星大法
大功告成 奥特曼状态(rank=20 hp=150 damage=35 exp=25 money=125)
怪兽状态(rank=20 hp=400 damage=40 exp=200 money=200)
有缘相会
有缘有分
奥特曼状态(rank=20 hp=550 damage=75 exp=225 money=325)

#include
#include 
using namespace std;
class Monster;
class Ultraman {
	private:
		int rank; // 等级
		int hp;	 	//生命值
		int damage;	//攻击力
		int exp;	//经验
		int money;	//钱
	public:
		Ultraman(int);
		Ultraman& operator++(void);
		Ultraman& operator--(void);
		bool operator<(Monster&);
		bool operator==(Monster&);
		friend ostream & operator<<( ostream & os,const Ultraman & Tiga);
};
class Monster {
	protected:
		int rank; // 等级
		int hp;	 	//生命值
		int damage;	//攻击力
		int exp;	//经验
		int money;	//钱
	public:
		Monster(int);
		int get_rank();
		int get_hp();
		int get_exp();
		int get_money();
		int get_damage();
		void display();
		
};
Ultraman::Ultraman(int a) {
	rank=a;
	hp=10*a;
	exp=0;
	damage=3*a;
	money=10*a;
}
Ultraman &Ultraman::operator++(void){
	rank=rank*2;
	hp=10*rank;
	damage=3*rank;
	exp=exp*2;
	money=money*2;
	return *this;
}
Ultraman &Ultraman::operator--(void){
	hp=hp/2;
	damage=damage/2;
	exp=exp/2;
	money=money/2;
	return *this;
}
bool Ultraman::operator<(Monster& Viga){
	if(Viga.get_rank()<rank){
		hp+=(Viga.get_hp()/2);
	damage+=(Viga.get_damage()/2);
	exp+=(Viga.get_exp()/2);
	money+=(Viga.get_money()/2);
	return 1;
	}
	else
	return 0; 
}
bool Ultraman::operator==(Monster& Viga){
	if(Viga.get_rank()==rank){
		hp+=Viga.get_hp();
	damage+=Viga.get_damage();
	exp+=Viga.get_exp();
	money+=Viga.get_money();
	return 1;
	}
	else
	return 0; 
}
ostream &operator<<(ostream & os,const Ultraman &Tiga) {
	os<<"奥特曼状态(rank="<<Tiga.rank;
	os<<" hp="<<Tiga.hp;
	os<<" damage="<<Tiga.damage;
	os<<" exp="<<Tiga.exp;
	os<<" money="<<Tiga.money<<")"<<endl;
	return os;
}

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::display(){
	cout<<"怪兽状态(rank="<<rank;
	cout<<" hp="<<hp;
	cout<<" damage="<<damage;
	cout<<" exp="<<exp;
	cout<<" money="<<money<<")"<<endl;
}
int main() {
	int ograd;
	cin>>ograd;//输入奥特曼的等级值，利用等级值，声明一个奥特曼对象。
	Ultraman uobj(ograd);
	cout<<uobj;  //显示奥特曼对象初始状态
	int t;
	cin>>t;//输入测试次数
	while(t--) {
		char c=0;
		while(1) {
			cin>>c;//输入要使用的魔法袋，G代表好事成双，B代表祸不单行，X代表吸星大法，Y代表有缘相会
			if(c=='G')   {
				cout<<"****好事成双****"<<endl;
				++uobj;
				cout<<"****成功翻倍****"<<endl;
				break;
			}
			else if(c=='B') {
				cout<<"****祸不单行****"<<endl;
				--uobj;
				cout<<"****不幸减半****"<<endl;
				break;
			}
			else if(c=='X') {
				int r;
				cin>>r;//输入怪兽的等级值，利用等级值，声明一个怪兽对象并显示对象初始状态。
				Monster mobj(r);
				mobj.display();
				cout<<"****吸星大法****"<<endl;
				if(uobj<mobj) cout<<"****大功告成****"<<endl;
				else cout<<"****尚未成功****"<<endl;
				break;
			}
			else if(c=='Y') {
				int r;
				cin>>r;//输入怪兽的等级值，利用等级值，声明一个怪兽对象并显示对象初始状态。
				Monster mobj(r);
				mobj.display();
				cout<<"****有缘相会****"<<endl;
				if(uobj==mobj)cout<<"****有缘有分****"<<endl;
				else cout<<"****无缘无分****"<<endl;
				break;
			}
			else cout<<"请重新输入魔法袋类型"<<endl;
		}
		cout<<uobj;
	}
	return 0;
}

运算符重载函数作为类的成员函数

成员运算符重载函数在类中的声明格式为：
class X
{ ……
<返回数据类型> operator <运算符> (<参数表>)；
……
};

成员运算符重载函数在类外定义的格式为：
<返回数据类型> X:: operator <运算符> (<参数表>)
{
<函数体>
}