运算符重载----------C++知识

为什么运算符也能重载呢？相必大家都听过C++的函数重载，其实运算符本质上也是函数。

我们为什么需要运算符重载呢？

举个例子：

我们实现加法的时候可以 1+1来计算基础数据类型的和，但是想类的相加，用这个普通的 + 肯定是不行的，语法也不支持。于是就有了运算符重载的概念。

运算符重载也是函数，和函数具有一样的结构

返回值类型  函数名 （形参列表）{函数体}

运算符重载

返回值类型   operator‘需要重载的符号’(形参列表){函数体}

operator 是一个运算符重载的标志

下面我们来用代码来实现运算符重载。

用到了两个小函数

int min(int a, int b)
{
	if (a > b) return b;
	else return a;
}

void yueFen(int& a, int& b)	 //约分函数
{
	//约分
	int i = 1;	//i是除数
	while (i < min(a, b))
	{
		++i;
		if (a % i == 0 && b % i == 0)
		{
			a = a / i;
			b = b / i;
			i = 1;
		}
	}
}   

类的结构

class Fenshu
{
public:
	int fenzi;
	int fenmu;
	//运算符重载
	Fenshu& operator =(const Fenshu& f);
	Fenshu operator+(const Fenshu& f);
	Fenshu operator-(const Fenshu& f);
	Fenshu operator*(const Fenshu& f);
	Fenshu operator/(const Fenshu& f);

	//构造函数
	Fenshu(){}
	Fenshu(int a, int b):fenzi(a),fenmu(b){}
	friend bool operator !=(const Fenshu& i, const Fenshu& j);

	friend bool operator >=(const Fenshu& i, const Fenshu& j);
	friend bool operator <=(const Fenshu& i, const Fenshu& j);
	friend bool operator >(const Fenshu& i, const Fenshu& j);
	friend bool operator<(const Fenshu& i, const Fenshu& j);

};

//   =号
Fenshu& Fenshu:: operator =(const Fenshu& f)
{
	this->fenzi = f.fenzi;
	this->fenmu = f.fenmu;
	return *this;
}
//加法 （成员函数）
Fenshu Fenshu:: operator +(const Fenshu& f)	//f加上const为了 不让函数修改右值
{
	Fenshu temp;
	temp.fenzi = f.fenzi * this->fenmu + f.fenmu * this->fenzi;
	temp.fenmu = f.fenmu * this->fenmu;
	//约分
	yueFen(temp.fenmu, temp.fenzi);
	return temp;
}
//减法  （成员函数)
Fenshu Fenshu:: operator -(const Fenshu& f)
{
	Fenshu temp;
	temp.fenmu = f.fenmu * this->fenmu;
	temp.fenzi = this->fenzi * f.fenmu - f.fenzi * this->fenmu;
	yueFen(temp.fenmu, temp.fenzi);
	return temp;
}
//乘法	（成员函数)
Fenshu Fenshu::operator *(const Fenshu& f)
{
	Fenshu temp;
	temp.fenmu = f.fenmu * this->fenmu;
	temp.fenzi = f.fenzi * this->fenzi;
	yueFen(temp.fenmu, temp.fenzi);
	return temp;
}
//除法  (成员函数)
Fenshu Fenshu:: operator /(const Fenshu& f)
{
	Fenshu temp1;
	temp1.fenmu = f.fenzi;
	temp1.fenzi = f.fenmu;
	Fenshu temp2 = *this * temp1;
	yueFen(temp2.fenzi, temp2.fenmu);
	return temp2;		//*this 是本对象    后面的*是运算符的重载
}
//  ==号
bool operator ==(const Fenshu& i, const Fenshu& j)
{
	Fenshu a = i;//用来替换
	Fenshu b = j;
	if (a.fenmu % a.fenzi == 0)
	{
		a.fenmu = a.fenmu / a.fenzi;
		a.fenzi = 1;
	}

	if (b.fenmu % b.fenzi == 0)
	{
		b.fenmu = b.fenmu / b.fenzi;
		b.fenzi = 1;
	}
	if (a.fenzi == b.fenzi && a.fenmu == b.fenmu)
	{
		return true;
	}
	else  return false;

}
//  !=号
bool operator !=(const Fenshu& i, const Fenshu& j)
{
	Fenshu a = i;//用来替换
	Fenshu b = j;
	if (a.fenmu % a.fenzi == 0)
	{
		a.fenmu = a.fenmu / a.fenzi;
		a.fenzi = 1;
	}

	if (b.fenmu % b.fenzi == 0)
	{
		b.fenmu = b.fenmu / b.fenzi;
		b.fenzi = 1;
	}
	if (a.fenzi != b.fenzi || a.fenmu != b.fenmu)
	{
		return true;
	}
	else  return false;

}
//  >=
bool operator >=(const Fenshu& i, const Fenshu& j)
{
	Fenshu a = i;//用来替换
	Fenshu b = j;
	int fenmu = a.fenmu * b.fenmu;
	int aFenzi = a.fenzi * b.fenmu;
	int bFenzi = b.fenzi * a.fenmu;

	if (aFenzi >= bFenzi) return 1;
	else return 0;
	
}
//   <=
bool operator <=(const Fenshu& i, const Fenshu& j) 
{
	Fenshu a = i;//用来替换
	Fenshu b = j;
	int fenmu = a.fenmu * b.fenmu;
	int aFenzi = a.fenzi * b.fenmu;
	int bFenzi = b.fenzi * a.fenmu;

	if (aFenzi <= bFenzi) return 1;
	else return 0;
}
//   >
bool operator >(const Fenshu& i, const Fenshu& j)
{
	Fenshu a = i;//用来替换
	Fenshu b = j;
	int fenmu = a.fenmu * b.fenmu;
	int aFenzi = a.fenzi * b.fenmu;
	int bFenzi = b.fenzi * a.fenmu;

	if (aFenzi > bFenzi) return 1;
	else return 0;
}
//   <
bool operator<(const Fenshu& i, const Fenshu& j)
{
	Fenshu a = i;//用来替换
	Fenshu b = j;
	int fenmu = a.fenmu * b.fenmu;
	int aFenzi = a.fenzi * b.fenmu;
	int bFenzi = b.fenzi * a.fenmu;

	if (aFenzi < bFenzi) return 1;
	else return 0;
}