掘根宝典之C++运算符重载
什么是运算符重载
运算符重载是一种形式的C++多态。这很容易让大家想到函数多态，让我们使用同名的函数来完成相同的基本操作，即使是用于不同的类型，不懂函数多态的看这里http://t.csdnimg.cn/ipbqR
运算符重载把重载的概念拓展到运算符上，允许赋予C++运算符多种含义。
实际上C++已经重载了很多运算符了，比如"*“，可以用于乘法，也可以用于解引用
C++根据操作数的数目和类型来决定采用哪种操作
例如啊，我们知道数组是不能相加的啊，那我们可以通过重载运算符来实现数组“相加”，赋予特定意义
实现下面这种操作
int a[10];
int b[10];
int c=a+b;实现运算符重载
重载运算符的本质是编写以运算符为名称的函数
格式为
返回类型 operator运算符 （参数列表）
{
函数体
}先看个例子
#include
using namespace std;
class AA
{
private:
int a_;
public:
AA(int a)
{
a_ = a;
}
//重载运算符
int operator+(AA& t)
{
return a_ + t.a_;
}
};
int main()
{
AA e = { 2 };
AA r = { 3 };
//检查运算符结果
cout << e + r << endl;
} 发现打印出来的是5，这说明我们重载后的+也可以用于对象相加了
重载运算符的规则
重载运算符有以下限制：
1. 重载运算符只能作用于自定义类型的对象，不能用于内置类型（如int、float等），也就是说重载之后的运算符的操作数必须有一个是自定义类型。
2.C++中不允许用户定义新的运算符，只能对已有的运算符进行重载，
3.重载后的运算符的优先级、结合性也应该保持不变，也不能改变其操作个数和语 法结构。
4.重载后的含义，与操作基本数据类型的运算含义应类似，如加法运算符“+”，重 载后也应完成数据的相加操作。
5.有5个运算符不可重载：类关系运算符“：”、成员指针运算符“*”、作用域运算 符“::”、sizeof运算符、三目运算符“？：”
6.运算符重载函数不能有默认参数，否则就改变了运算符操作数的个数，是错误的。
7.运算符重载函数既可以作为类的成员函数，也可以作为类的友元函数，也可以是全局函数。
8.作为全局函数时，一般都需要在类中将该函数声明为友元函数。因为该函数大部分情况下都需要使用类的private成员。
9.作为类的成员函数时，二元运算符的参数只有一个， 一元运算符不需要参数（参数没有任何意义，只是为了区分是前置还是后置形式：带 一个整型参数为后置形式）。因为有个参数（左操作数）是隐含的（隐式访问this指针 所指向的当前对象）。
10.作为全局函数或者友元函数时，二元操作符需要两个参数，一元操作符需要一 个参数，而且其中必须有一个参数是对象，好让编译器区分这是程序员自定义的运算符， 防止程序员修改用于内置类型的运算符的性质。
重载运算符的几种情况
1.重载为普通全局函数
重载运算符可以是普通函数，但是有个限制，就是它的函数参数必须有一个类类型或枚举类型
看个例子
#include
using namespace std;
class AA
{public: //注意是public
int a;
int b;
};
int operator+(AA t,AA y)//可以
{
return t.a + y.a;
}
int operator+(AA t,int y)//可以
{
return t.a + y;
}
int operator+(int t,int y)//这是不行的
{
return t+ y;
}
int main()
{
AA f = { 1,2 };
AA g = { 3,4 };
cout << f + g << endl;
cout<< f+3< 但是上面的AA类的数据成员是public的（如果是private的话，普通全局函数没权限访问），这违反了类的原则之一——数据隐藏，所以我们很少重载为普通的全局函数
2.重载为类的成员函数
重载运算符最常见的就是在类里面作为类方法进行重载的
(1),双目运算符
如果是双目运算符重载为类的成员函数，则它有两个操作数：左操作数是对象本身 的数据，由this指针指出（我们不写），右操作数则通过运算符重载函数的参数表来传递（必须要写）。
也就是说，我们只需写下右操作数即可
定义格式：
返回类型 operator操作符（右操作数类型）
{
函数体
}调用格式为：
左操作数 操作符 右操作数 编译器会自动将上面这个语句展开为下面这种
左操作数.operator运算符（右操作数）当然我们也可以直接使用第二种
看个例子
#include
using namespace std;
class A
{
private:
int x, y;
public:
A(int x1 = 0, int y1 = 0) //默认构造函数
{
x = x1;
y = y1;
}
A operator+(const A& a)const //const成员函数，运算符重载
{
A t;
t.x = this->x + a.x;
t.y = this->y + a.y;
return t;
}
void show()
{
cout << "x=" << x << "," << "y=" << y << endl;
}
};
int main()
{
A a1(1, 2);
A a2(3, 4);
A a;
a = a1 + a2;//实际上等价于a=a1.operator+(a2);
a.show();
} 输出结果
x=4,y=6我们这也是成功重载运算符+
(2),单目运算符
如果是单目运算符重载为类的成员函数，则要分为前置(++i)和后置(i++)运算符。
如果是前置运算符，则它的操作数是函数调用者，函数没有参数。
前置调用格式为：
操作符 操作数；被编译器展开为
操作数.operator运算符（）后置调用格式为
操作数 操作符；被编译器展开为
操作数.operator运算符（操作数类型）举个例子
#include
using namespace std;
class A
{
private:
int x, y;
public:
A(int x1 = 0, int y1 = 0)
{
x = x1;
y = y1;
}
A &operator++()//++i 前置++实现
{
++x; //先自增
++y;
return *this; //后引用
}
A operator++(int) //i++ 后置++实现
{
//int参数没有任何意义，只是为了区分是前置还是后置形式
A a = *this; //保存对象引用
++(*this); //自增，调用前面实现的前置++
return a; //返回先前保存的对象
}
void show()
{
cout << "x=" << x << "," << "y=" << y << endl;
}
};
int main()
{
A a1(1, 2), a2(3, 4);
(a1++).show();
(++a2).show();
return 0;
} 输出结果
x=1,y=2
x=4,y=5
实现前置“++”时，数据成员进行自增运算，然后返回当前对象（即this指针所指 向的对象）。实现后置“++”时，创建了一个临时对象来保存当前对象的值，然后再将当前对象自增，最后返回的是保存了初始值的临时对象。
注意：前置单目运算符和后置单目运算符的最主要区别是函数的形参，后置单目运 算符带一个int型形参，但它只起区分作用。
3.重载为类的友元函数
运算符重载为类的友元函数，只是在函数前加一个friend关键字。
(1)重载格式
friend 返回类型 operator 运算符（参数列表）
{
函数体；
}说明：运算符重载为类的友元函数时，由于没有隐含的this指针，因此，操作数的个数没有变化，所有的操作数都必须通过函数形参进行传递，函数的参数与操作数 自左自右保持一一对应。
调用格式为：
左操作数 操作符 右操作数 编译器会自动将上面这个语句展开为下面这种
operator 运算符（左操作数，右操作数）；例如：调用a1+a2相当于函数调用operator+(a1, a2)
下面看一个例子：
将”+”运算符重载为类的友元函数
#include
using namespace std;
class A
{
private:
int x, y;
public:
A(int x1 = 0, int y1 = 0)
{
x = x1;
y = y1;
}
friend A operator+(const A& a, const A& b);
void show()
{
cout << "x=" << x << "," << "y=" << y << endl;
}
};
A operator+(const A& a, const A& b)
{
return A(a.x + b.x, a.y + b.y);
}
int main()
{
A a1(1, 2), a2(3, 4);
A c;
c = a1 + a2;//可以替换为c=operator+(a1,a2);
c.show();
return 0;
} 输出结果
x=4,y=6
4.两种重载方式的选择（不包括普通全局函数）
多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的，但两者各具特点：
1,一般，单目运算符最好重载为类的成员函数，双目运算符最好重载为类的友元函数。
2,若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。
3,若运算符的操作数（尤其是第一个操作数）可能有隐式类型转换，则只能选用友元函 数。
4,具有对称性的运算符可能转换任意一端的运算对象，如：算术(a+b和b+a)、关系运算 符(a>b和b
5,有4个运算符必须重载为类的成员函数：赋值＝、下标[ ]、调用( )、成员访问->。
重载
常用运算符的重载
1.输入输出运算符的重载
C++标准库对左移运算符<<和右移运算符>>分别进行了重载，使其能够用于不同数 据的输入输出。对于基本类型数据（如bool、int、double等）和标准库所包含的 类（如string、complex、ofstream、ifstream等）可以直接使用输入运算符“>>”、 输出运算符“<<”进行读写操作。对于自己定义的新数据类型（如：类对象）则需要重载这两个运算符。
cout<>obj1; //cout是ostream类的对象，cin是istream类的 对象 由于输入输出操作的第一个操作数为ostream/istream对象，也就是说左侧的运算 对象必须是ostream/istream对象，如果重载成类的成员函数，则左侧的操作对 象将是我们定义的一个类对象（需要修改标准库中的类，显然不是我们所期望 的）。因此输入输出运算符不可重载为类的成员函数，只能重载为非成员函数 （全局函数，友元函数）。
重载“<<”和“>>”运算符的一般格式为：
istream& operator>>(istream&, 类对象引用); //输入运算符>>重载
ostream& operator<<(ostream&, const 类对象引用); //输出运算符<<重载说明
（1）对于输入运算符来说，第一个参数是istream对象的引用，第二个参数是要 向其中存入数据的对象，不能为常量。返回istream类对象的引用（可作为下次调 用时的第一个参数），是为了能够连续读取：cin>>c1>>c2;，让代码书写更加漂亮。 如果不返回引用，就只能一个一个地读取：cin>>c1; cin>>c2;
cin>> c; 可以理解为：operator >> (cin , c);
（2）对于输出运算符“<<”来说，第一个参数是ostream对象引用，因为向流中 写入数据会改变流的状态 ，所以不能用const修饰ostream对象。由于采用了引用 的方式进行参数传递，并且也返回了对象的引用，所以重载后的运算符可以实现连 续输出。
cout<< c; 可以理解为：operator<< (cout , c);
案例
#include
using namespace std;
class A
{
private:
int x, y;
public:
A(int x1 = 0, int y1 = 0)
{
x = x1;
y = y1;
}
friend istream& operator>>(istream& is, A& a);
friend ostream& operator<<(ostream& os, const A& a);
};
istream& operator>>(istream& is, A& a)
{
is >> a.x >> a.y;
return is;
}
ostream& operator<<(ostream& os, const A& a)
{
os << "x=" << a.x << "," << "y="<> a1;
cout << a1;
return 0;
} 输出结果
21 88
x=21,y=88
重载输入输出运算符后，便可像基本数据类型一样直接对类对象进行输入输出，不 用再编写用于输入输出对象数据成员的show()等成员函数，而且使用起来更为简洁。
注意：
通常情况下，输出运算符主要负责输出对象的内容，而非控制格式，此时不应该把 换行符也重载进去。如果把换行符也重载进去，用户有时想在同一行输出一些描述 性的文本，就无法完成了。因此，在重载输出运算符时，应尽量少一些格式化操作， 可以使用户控制更多的输出细节。
2，关系运算符的重载
关系运算符（如“==”或“<”）也是较常用的一类运算符，同样，若类对象间需要 完成比较操作，也应完成对关系运算符的重载。关系运算符重载的过程非常直观。 重载关系运算符一般都返回true或false值。
关系运算符共有六个，并且相互之间有对应关系，如小于运算符“<”与大于运算 符“>”对应，因此对于关系运算符的重载应成对完成。
可重载为类的成员函数也可重载为类的友元函数（具有对称性的运算符通常重载为 类的友元函数）
案例
#include
using namespace std;
class A
{
private:
int x, y;
public:
A(int x1 = 0, int y1 = 0)
{
x = x1;
y = y1;
}
friend bool operator>(const A& a1,const A& a2);
friend bool operator<(const A& a1,const A& a2);
friend bool operator==(const A& a1, const A& a2);
};
bool operator>(const A& a1, const A& a2)
{
return a1.x > a2.x;
}
bool operator<(const A& a1, const A& a2)
{
return a1.x < a2.x;
}
bool operator==(const A& a1, const A& a2)
{
return a1.y == a2.y;
}
int main()
{
A a1(1, 2);
A a2(3, 2);
if (a1 > a2)
{
cout << "a1的x大于a2的x"< 输出结果
a1的x小于a2的x
a1的y都等于a2的y
重载了”>”，”<”,”==”的关系运算符，其他的也是一样，重载关系运算符之后可以直 接比较对象的大小，实际上”>”,”<”只是比较了对象中的x值，”==”只是比较了对象 中的y值，
重载关系运算符的准则
（1）关系运算符都要成对的重载。如：重载了“<”运算符，就要重载“>” 运算符，反之亦然。
（2）“==”运算符应该具有传递性。如：a==b，b==c，则a==c成立。
（3）当成对出现运算符重载时，可以把一个运算符的工作委托给另一个运算 符。如：重载“!=”运算符是在“==”运算符的基础上，重载“<”运算 符 由重载过的“>”运算符来实现。