一、操作符函数重载
什么是操作符函数：在C++中针对类类型的对象的运算符，由于它们肯定不支持真正的运算操作，因此编译器会将它们翻译成函数，这种就叫做
操作符函数（运算符函数）。
编译器把运算翻译成运算符函数，可以针对自定义的类类型设计它独有的运算功能。
其实各种运算符已经具备一些功能，再次实现它的就是叫作运算符重载。
双目运算符：
a+b
成员函数
a.operator+(b);
全局函数
operator+(a,b);
单目运算符：
!a
成员函数
a.operator!(void);
全局函数
operator!(a);
二、双目操作符函数重载
成员函数：
const 类对象 operator#(const 类& that) const
{
return 类(参数#参数);
}
注意：双目录运算符的运算结果是个右值，返回值应该加 const ，然后为了const对象能够调用，参数应写const，函数也应该具备const属性。
全局函数：
const 类 operator#(const 类& a,const 类& b)
{
}
注意：全局函数不是成员函数，可能会需要访问到类的私有成员，解决这种问题可以把函数声明为类的友元函数（友元不是成员）。
友元：在类的外部想访问类的私有成员（public/protected/private）时，需要把所在的函数声明为友元，但是友元只是朋友，因此它只有访
问权，没有实际的拥有权（其根本原因是它没有this指针）。
友元声明：把函数的声明写一份到类中，然后在声明前加上friend 关键字。使用友元即可把操作符函数定义为全局的，也可以确保类的封装性。
注意：友元函数与成员函数不会构成重载关系，因此它们不在同一个作用域内。
三、赋值类型的双目操作符
成员
类 operator#(void)
{
}
全局
类 operator#(const 类& that)
{
}
1、获取单参构造成赋值运算的调用方式。
String str = “xxx”; // 会调用单参构造，而不调用赋值运算符
str = “hhh”;
2、左操作数据不能具有const属性
1.成员函数不能是常函数
2.全局函数第一个参数不能有const属性
3、返回值应该都（成员/全局）具备const属性
四、单目操作符函数重载
-,~,!,&,*,->,++,–
成员
const 类 operator#(void) const
{
}
全局
const 类 operator#(const 类& that)
{
}
前++/–
类& operator#(void)
{
}
类& operator#(类& that)
{
}
后++/–(哑元)
const 类& operator#(void)
{
}
const 类& operator#(类& that,int)
{
}
五、输入输出操作符重载
cout 是 ostream 类型的对象，cin 是 istream 类型的对象。
如果<</>>运算实现为成员函数，那么调用者应该是ostream/istream,而我们无权增加标准库的代码，因此输入/输出运算符只能定义为全局函数。
ostream& operator<<(ostream& os,const 类& n)
{
}
istream& operator>>(istream& os,类& n)
{
}
注意：在输入输出过程中，cin/cout会记录错误标志，因此不能加const属性。
关于操作符重载的建议：
1、在重载操作符时要根据操作符实际的功能和意义来确定具体参数，返回值，是否具有const属性，返回值是否是引用或者临时对象。
2、重载操作符要符合情理（要有意义），要以实际用途为前提。
3、重载操作符的意义是为了让对象的操作更简单、方便，而不是为了炫技。
相关测试代码：
#include <iostream>
using namespace std;
class Point
{
int x;
int y;
public:
Point(int _x=0,int _y=0)
{
x = _x;
y = _y;
}
/* void show(void) const
{
cout<< "(x:" <<x <<",y:" <<y<< ")"<<endl;
}*/
friend const Point operator+(const Point& a,const Point& b);
friend const Point operator-(const Point& a,const Point& b);
friend const Point operator*(const Point& a,int b);
friend const Point operator*(int a,const Point& b);
const Point operator/(const int that) const
{
return Point(x/that,y/that);
}
/* const Point operator+(const Point& that) const
{
return Point(that.x+x,that.y+y);
}
*/
const Point& operator+=(const Point& that)
{
x += that.x;
y += that.y;
cout<<"___";
return *this;
}
Point operator-(void)
{
return Point(-x,-y);
}
// 前++
Point& operator++(void)
{
x++;
y++;
return *this;
}
// 后++ (哑元)
/* Point operator++(int)
{
Point temp(x,y);
x++;
y++;
return temp;
}
*/
friend Point operator++(Point& that,int);//友元
Point operator--(int)
{
Point temp(x,y);
x--;
y--;
return temp;
}
friend ostream& operator<<(ostream& os,const Point& p);
friend istream& operator>>(istream& is,Point& p);
};
ostream& operator<<(ostream& os,const Point& p)
{
return os <<p.x<<","<<p.y;
}
istream& operator>>(istream& is,Point& p)
{
cout << "请输入x的值:";
is >> p.x;
cout<<"请输入y的值：";
is >> p.y;
return is;
}
Point operator++(Point& that,int)
{
Point temp(that.x,that.y);
that.x++;
that.y++;
return temp;
}
const Point operator+(const Point& a,const Point& b)
{
return Point(a.x+b.x,a.y+b.y);
}
const Point operator-(const Point& a,const Point& b)
{
return Point(a.x-b.x,a.y-b.y);
}
const Point operator*(const Point& a,int b)
{
return Point(a.x*b,a.y*b);
}
const Point operator*(int a,const Point& b)
{
return Point(a*b.x,a*b.y);
}
int main()
{
Point p(3,9);
Point p1(1,3);
Point p2 = p1+p+p1;
cout<<"+:";
cout<<p2<<endl;
Point p4(6,6);
cin>>p4;
cout<<p4<<endl;
// p2.show();
p2 = p2-p1;
cout<<"-:";
cout<<p2<<endl;
// p2.show();
p2 = p1*3;
cout<<"*:";
cout<<p2<<endl;
// p2.show();
p2 = 3*p1;
// p2.show();
cout<<p2<<endl;
cout<<(-p1)<<endl;
// (-p1).show();
p2 = p1;
// p2.show();
// (++p1).show();
cout<<(++p1)<<endl;
// (p2++).show();
cout<<"p2:"<<(p2++)<<endl;
cout<<"p2:"<<p2<<endl;
// p2.show();
cout<<"p2:"<<(p2--)<<endl;
cout<<"p2:"<<p2<<endl;
// (p2--).show();
// p2.show();
p2 = p2/3;
// p2.show();
cout<<"p2:"<<p2<<endl;
}
如有错误，望指出，谢谢~
来源：https://blog.csdn.net/Ikaros_521/article/details/99693057