实现一个Money类

要求：

1.Money类有两个数据成员：金币数量和银币数量，每一个金币等于1000个银币。

2.实现+，-，*，/。

3.实现++，--运算符的重载（银币加减100）。

4.实现=运算符的重载。

5.实现==，！=，>=，<=，<，>运算符的重载。

6.实现>>,<<运算符的重载。

#include <iostream>
#include "stdio.h"
#include "string"
using namespace std;
class Money
{
private:
	float gold_;
	float silver_;
	static const int ratio = 1000;
public:
	Money(int gold = 0, int silver = 0);
	~Money();
	Money operator+(const Money& m);
	Money operator-(const Money& m);
	Money operator*(const int n);
	Money operator/(const int n);
	Money& operator++();
	Money& operator--();
	Money& operator=(const Money& m);
	bool operator==(const Money& m);
	bool operator!=(const Money& m);
	bool operator>=(const Money& m);
	bool operator<=(const Money& m);
	bool operator<(const Money& m);
	bool operator>(const Money& m);
	friend ostream& operator<<(ostream& os, const Money& m);
	friend istream& operator>>(istream& is, Money& m);



};

int main()
{
	Money m1 = Money(100, 600);
	Money m2 = Money(100, 500);
	Money m3 = m1;
	Money m4 = m3 + m2;
	Money m5 = m1 * 2;
	++m3;
	Money m6 = m5 / 2;
	cout << m1 << endl << m2 << endl << m3 << endl << m4 << endl << m5 << endl << m6 << endl;
	Money m7;
	cout << "请输入m7的值： ";
	cin >> m7;
	Money m8;
	cout << "请输入m8的值： ";
	cin >> m8;
	if (m7 == m8)
		cout << "m7等于m8" << endl;
	else if (m7 > m8)
	{
		cout << "m7大于m8" << endl;
	}



}

Money::Money(int gold, int silver)
{
	gold_ = gold;
	silver_ = silver;
}

Money::~Money() {}

Money Money::operator+(const Money& m)
{
	Money money;
	int i = this->gold_ * ratio + m.gold_ * ratio + this->silver_ + m.silver_;
	money.gold_ = i / ratio;
	money.silver_ = i % ratio;
	return money;
}

Money Money::operator-(const Money& m)
{
	Money money;
	int i = this->gold_ * ratio - m.gold_ * ratio + this->silver_ - m.silver_;
	money.gold_ = i / ratio;
	money.silver_ = i % ratio;
	return money;
}

Money Money::operator*(const int n)
{
	Money money;
	int i = this->gold_ * ratio * n + this->silver_ * n;
	money.gold_ = i / ratio;
	money.silver_ = i % ratio;
	return money;
}

Money Money::operator/(const int n)
{
	Money money;
	int i = (this->gold_ * ratio + this->silver_) / n;
	money.gold_ = i / ratio;
	money.silver_ = i % ratio;
	return money;
}

Money& Money::operator++()
{
	int i = this->gold_ * ratio + this->silver_;
	i += 100;
	this->gold_ = i / ratio;
	this->silver_ = i % ratio;
	return*this;
}

Money& Money::operator--()
{
	int i = this->gold_ * ratio + this->silver_;
	i -= 100;
	this->gold_ = i / ratio;
	this->silver_ = i % ratio;
	return*this;
}

Money& Money::operator=(const Money& m)
{
	this->gold_ = m.gold_;
	this->silver_ = m.silver_;
	return *this;
}

bool Money::operator==(const Money& m)
{
	if ((this->gold_ * ratio + this->silver_) == (m.gold_ * ratio + m.silver_))
		return true;
	else
		return false;
}

bool Money::operator!=(const Money& m)
{
	if ((this->gold_ * ratio + this->silver_) != (m.gold_ * ratio + m.silver_))
		return true;
	else
		return false;
}

bool Money::operator>=(const Money& m)
{
	if ((this->gold_ * ratio + this->silver_) >= (m.gold_ * ratio + m.silver_))
		return true;
	else
		return false;
}

bool Money::operator<=(const Money& m)
{
	if ((this->gold_ * ratio + this->silver_) <= (m.gold_ * ratio + m.silver_))
		return true;
	else
		return false;
}

bool Money::operator<(const Money& m)
{
	if ((this->gold_ * ratio + this->silver_) < (m.gold_ * ratio + m.silver_))
		return true;
	else
		return false;
}

bool Money::operator>(const Money& m)
{
	if ((this->gold_ * ratio + this->silver_) > (m.gold_ * ratio + m.silver_))
		return true;
	else
		return false;
}

ostream& operator<<(ostream& os, const Money& m)
{
	os << "金币数量：" << m.gold_ << "  " << "银币数量：" << m.silver_ << endl;
	return os;

}

istream& operator>>(istream& is, Money& m)
{
	is >> m.gold_ >> m.silver_;
	if (!is)
	{
		m = Money();
	}
	return is;


}

1）const成员函数可以访问非const对象的非const数据成员、const数据成员，也可以访问const对象内的所有数据成员；

2）非const成员函数可以访问非const对象的非const数据成员、const数据成员，但不可以访问const对象的任意数据成员；

3）作为一种良好的编程风格，在声明一个成员函数时，若该成员函数并不对数据成员进行修改操作，应尽可能将该成员函数声明为const 成员函数。

4）如果只有const成员函数，非const对象是可以调用const成员函数的。当const版本和非const版本的成员函数同时出现时，非const对象调用非const成员函数。