运算符重载

定义

• 所谓重载，就是重新赋予新的含义，函数重载是对一个已有的函数赋予新的含义。

方法

• 运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该运算符。也就是说，运算符重载是通过定义函数实现的，运算符重载实质是是函数的重载。

格式

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

例如： 把加号运算符重载成乘号运算符

int operate + (int a,int b)
{return(a*b);
}

TIPS

• 运算符重载函数除了可以作为类的成员函数外，还可以是非成员函数： 放在类外，作Complex的友元函数存在。(不推荐)（由于友元的使用会破坏类的封装，因此从原则上说，要尽量讲运算符函数作为成员函数。）
• 去重载一个操作符，应该只有在必要的时候，比如实现一种新的数据类型时，才重载操作符。
• 重载操作符的目的是为了让代码更容易阅读和理解。

左移运算符重载

• 重载左移运算符也属于运算符的重载，不过语法有所不同。

• 下面是一个 operate << () 函数声明的原型：

    std::ostream& operator << (std::ostream& os, Fenshu in);
  

• 第一个数参数os是将要写入的流，它是以“引用传递”的方式传递的。

• 第二个参数是打算写到那个流里面的数据值，不同的operator 函数就是因为这个输入参数才互相区别的。

注意： 第二个参数。不能使用传址，不然输出时，会改变参数的值，这在语法上也是不允许的。

代码实现

1/3 复数的加减乘除

#include<iostream>using namespace std;class Complex
{
public:Complex();Complex(double r,double i);void printf();Complex operator +(Complex &in){Complex temp;temp.imag=imag+in.imag;temp.real=real+in.real;return temp;}Complex operator -(Complex &in){Complex temp;temp.imag=imag-in.imag;temp.real=real-in.real;return temp;}Complex operator *(Complex &in){Complex temp;temp.imag=imag*in.real+in.imag*real;temp.real=real*in.real-imag*in.imag;return temp;}Complex operator /(Complex &in){Complex temp;temp.imag=(imag*in.real-real*in.imag)/((in.real*in.real)+(in.imag*in.imag));temp.real=(real*in.real+imag*in.imag)/((in.real*in.real)+(in.imag*in.imag));return temp;}private:double real;double imag;};
void Complex::printf()
{if(real==0){cout << "   "<<imag <<  "i" << endl;}else if(imag==0){cout << "   "<< real << endl;}else if(imag>0)cout << "( " << real << "+" << imag << "i ) " << endl;elsecout << "( " << real << imag << "i ) " << endl;}
Complex::Complex()
{real=0;imag=0;
}
Complex::Complex(double r,double i)
{real=r;imag=i;
}int main()
{Complex a(3,1);Complex b(1,-1);Complex c,d,e,f;c=a+b;d=a-b;e=a*b;f=a/b;a.printf();   cout << "加上" << endl;   b.printf();  cout << "的结果为" <<endl;  c.printf();cout << "\n" << endl;a.printf();   cout << "减去" << endl;   b.printf();  cout << "的结果为" <<endl;  d.printf();cout << "\n" << endl;a.printf();   cout << "乘上" << endl;   b.printf();  cout << "的结果为" <<endl;  e.printf();cout << "\n" << endl;a.printf();   cout << "除去" << endl;   b.printf();  cout << "的结果为" <<endl;  f.printf();return 0;
}

2/3 分数的加减乘除

#include <iostream>
#include <cmath>
using namespace std;class Fenshu
{
public:Fenshu();Fenshu(int num_in,int denum_in);void print();Fenshu operator +(Fenshu &in){Fenshu temp;temp.num=num*in.denum+denum*in.num;temp.denum=in.denum*denum;return temp;}Fenshu operator -(Fenshu &in){/*      num=-num;                 //法1：不好用：会改变num 的值，后面不好输出return operator +(in);*/Fenshu temp;temp.num=(-num)*in.denum+denum*in.num;temp.denum=in.denum*denum;return temp;    }Fenshu operator *(Fenshu &in){Fenshu temp;temp.num=num*in.num;temp.denum=in.denum*denum;return temp;}Fenshu operator /(Fenshu &in){Fenshu temp;temp.num=num*in.denum;temp.denum=in.denum*num;return temp;}
private:int num;int denum;void normalize();
};Fenshu::Fenshu()
{num=0;denum=0;
}
Fenshu::Fenshu(int num_in,int denum_in)
{num=num_in;denum=denum_in;normalize();
}
//normalize()对分数进行简化操作包括：
//1.只允许分子为负数，如果分母为负数则把负数挪到分子部分，如1/-2==-1/2
//2.利用欧几里德算法(辗转求余原理)将分数进行简化:2/10 => 1/5
void Fenshu::normalize()
{if(denum<0){num=-num;denum=-denum;}//用欧几里得算法求最大公约数：aint a=abs(num);int b=abs(denum);while(b>0){int t=a%b;a=b;b=t;}num/=a;denum/=a;
}
void Fenshu::print()
{normalize();if(num==0)                       //分子是0,结果就是0{cout << "0" << endl;}else if(denum==1){cout << num << endl;}elsecout << num << "/" << denum << endl;
}int main()
{Fenshu a(2,4),b(1,2),c;c=a+b;a.print();cout << "加上" << endl;b.print();cout << "的结果为：" << endl;c.print();a.print();cout << "减去" << endl;b.print();cout << "的结果为：" << endl;c=a-b;c.print();c=a*b;a.print();cout << "乘上" << endl;b.print();cout << "的结果为：" << endl;c.print();c=a/b;a.print();cout << "除去" << endl;b.print();cout << "的结果为：" << endl;c.print();return 0;
}

3/3： 对分数的运算添加左移运算符重载

#include <iostream>
#include <cmath>
using namespace std;class Fenshu
{
public:Fenshu();Fenshu(int num_in,int denum_in);void print();Fenshu operator +(Fenshu &in){Fenshu temp;temp.num=num*in.denum+denum*in.num;temp.denum=in.denum*denum;return temp;}Fenshu operator -(Fenshu &in){/*      num=-num;                 //法1：不好用：会改变num 的值，后面不好输出return operator +(in);*/Fenshu temp;temp.num=(-num)*in.denum+denum*in.num;temp.denum=in.denum*denum;return temp;}Fenshu operator *(Fenshu &in){Fenshu temp;temp.num=num*in.num;temp.denum=in.denum*denum;return temp;}Fenshu operator /(Fenshu &in){Fenshu temp;temp.num=num*in.denum;temp.denum=in.denum*num;return temp;}
private:int num;int denum;void normalize();friend ostream& operator <<(ostream& os,Fenshu t);};Fenshu::Fenshu()
{num=0;denum=0;
}
Fenshu::Fenshu(int num_in,int denum_in)
{num=num_in;denum=denum_in;normalize();
}
//normalize()对分数进行简化操作包括：
//1.只允许分子为负数，如果分母为负数则把负数挪到分子部分，如1/-2==-1/2
//2.利用欧几里德算法(辗转求余原理)将分数进行简化:2/10 => 1/5
void Fenshu::normalize()
{if(denum<0){num=-num;denum=-denum;}//用欧几里得算法求最大公约数：aint a=abs(num);int b=abs(denum);while(b>0){int t=a%b;a=b;b=t;}num/=a;denum/=a;
}ostream& operator<<(ostream & os,Fenshu t)  //////对左移运算符进行重载
{t.normalize();if(t.num==0)                       //分子是0,结果就是0{os << "0" ;}else if(t.denum==1){os << t.num;}elseos << t.num << "/" << t.denum;return os;
}
int main()
{Fenshu a(2,4),b(1,2);cout << a << " + " << b <<"= " << (a+b) << endl;cout << a << " - " << b <<"= " << (a-b) << endl;cout << a << " * " << b <<"= " << (a*b) << endl;cout << a << " / " << b <<"= " << (a/b) << endl;return 0;
}