【006】运算符重载

所谓重载，就是重新赋予新的含义。函数重载是对一个已有的函数赋予新的含义，使之实现新功能。

  其实运算符也可以重载。

  运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统自动调用该函数，以实现相应的运算。

  也就是说，运算符重载是通过定义函数实现的。运算符重载实质是函数的重载。

  重载运算符的函数一般格式如下：

  函数类型 operator 运算符名称（形参列表）
  {
      对运算符的重载处理
  }

  eg.  重载运算符"+"

  int operator+(int a,int b)
  {
     return(a-b);
  }

不能重载的运算符：
1. "." 成员访问运算符
2. ".*"成员指针访问运算符
3. "::"域运算符
4. "sizeof"尺寸运算符

5. "?:"条件运算符

练习

效果图：

代码：

#include<iostream>
#include<string>
#include<stdlib.h>
class Rational{
	public:
		Rational(int num,int denom);//num = 分子  denom = 分母
		
		Rational operator+(Rational rhs);//rhs == right hand side
		Rational operator-(Rational rhs);
		Rational operator*(Rational rhs);
		Rational operator/(Rational rhs);
		
		void print();
	private:
		void normalize();//负责对分数的简化处理
		int numerator;//分子
		int denominator;//分母	
		
		friend std::ostream& operator<<(std::ostream& os,Rational f );	
}; 		

Rational::Rational(int num,int denom){
	numerator = num;
	denominator = denom;
	
	normalize();
}

//normalize() 对分数进行简化操作包括
//1,只允许分子伟负数，如果分母为负数，则把负数挪到分子部分，如 1/-2 = -1/2
//2.利用欧几里算法（辗转求余原理）讲分数进行简化 :2/10 =>1/5

void Rational::normalize(){
	
	//确保分母为正
	if( denominator	< 0 ){
		numerator = -numerator;
		denominator = -denominator;
	} 
	//欧几里算法
	int a = abs(numerator);
	int b = abs(denominator);
	
	//求出最大公约数
	while( b > 0 ){
		int t = a % b;
	       	a = b;
		    b = t;
	} 
	 
	 //分子 、分母分别处以最大公约数得到最简化
	 numerator /= a;
	 denominator /= a; 
} 

// a    c    a*d    c*b    a*d + c*b
// -  + - = ----- + ---- = ----------
// b    d    b*d    b*d       b*d 
Rational Rational::operator+(Rational	 rhs){
	int a=numerator;
	int b=denominator;
	int c=rhs.numerator;
	int d=rhs.denominator;
	
	int e = a*b + c*d;
	int f = b*d;
	return Rational(e,f); 
}

// a    c    a   -c
// -  - - =  - + --
// b    d    b    d
Rational Rational::operator-(Rational	 rhs){
	rhs.numerator=-rhs.numerator;
	return operator+(rhs); 
}

// a   c   a*c
// - * - = ----
// b   d   b*d 
Rational Rational::operator*(Rational rhs){
	int a = numerator;
	int b = denominator;
	
	int c = rhs.numerator;
	int d = rhs.denominator;
	
	int e = a*c;
	int f = b*d;
	
	return Rational(e,f);		
}

//a   c     a   d
//- / -  =  - * -
//b   d     b   c

Rational Rational::operator/(Rational	 rhs){
	int t = rhs.numerator;
	rhs.numerator = rhs.denominator;
	rhs.denominator = t;

	return operator*(rhs);
}
void Rational::print(){  //1/8
	if(numerator % denominator == 0)
		std::cout<<numerator/denominator;
		else
		std::cout<< numerator<<"/"<<denominator;
}

//写声明 
std::ostream& operator<<(std::ostream& os,Rational f);
int main(){
	Rational f1(2,16);
	Rational f2(7,8);
	
	//测试有理数加法运算
	/*
	Rational res = f1+f2;
	f1.print();
	std::cout<<" + ";
	f2.print();
	std::cout<<" = ";
	res.print();
	std::cout<<"\n";*/
	std::cout<<f1<<"+"<<f2<<" == "<< (f1+f2)<<"\n";
	std::cout<<f1<<"-"<<f2<<" == "<< (f1-f2)<<"\n";
	std::cout<<f1<<"*"<<f2<<" == "<< (f1*f2)<<"\n";
	std::cout<<f1<<"/"<<f2<<" == "<< (f1/f2)<<"\n";
	
	/*
	//测试有理数减法运算
	res = f1-f2;
	f1.print();
	std::cout<<" - ";
	f2.print(); 
	std::cout<<" = ";
	res.print();
	std::cout<<"\n";
	
	//测试有理数乘法运算
	res = f1* f2;
	f1.print();
	std::cout<<" * ";
	f2.print(); 
	std::cout<<" = ";
	res.print();
	std::cout<<"\n";
	
		//测试有理数除法运算
	res = f1 / f2;
	f1.print();
	std::cout<<" / ";
	f2.print(); 
	std::cout<<" = ";
	res.print();
	std::cout<<"\n";*/
}
//写定义 
std::ostream& operator<<(std::ostream& os,Rational f){
	os<< f.numerator<<"/"<<f.denominator;
	return os;	
	
}