------------------siwuxie095
二元运算符重载
所谓 二元运算符，即 这个符号与两个操作数进行运算
（1）加号 + 的重载
加号 + 的重载方式有两种：一种是友元函数重载，一种是成员函数重载
1）先来看成员函数重载，如下：
定义一个坐标类：Coordinate
在类中声明成员函数 operator+()，它的参数是 const Coordinate &coor
在实现时：
首先需要定义一个临时对象 temp，传入对象 coor 的 m_iX 要和
当前对象的m_iX 相加，赋值给临时对象 temp 的 m_iX，而对于
m_iY 同理 … 最后将 temp 作为返回值返回出去
在使用时：
定义 3 个 Coordinate 的对象 coor1、coor2、coor3，用 coor3 来
接收coor1 与 coor2 相加的和，这里的加号 + 就已经用到了运算符
重载，相当于coor1.operator+(coor2)
注意：在加号 + 的重载函数 operator+() 的传入参数 coor2 的前面，
其实有一个隐形参数this，而 this 就相当于传入的第一个参数 coor1
2）再来看友元函数重载，如下：
友元函数重载相对于成员函数重载来说，更能说明问题：
通过friend 声明将全局函数 operator+() 声明为友元函数，它的两个
参数分别为：const Coordinate &c1 和 const Coordinate &c2
其中，const 可写可不写，如果写上，那么在 operator+() 中就不能再
修改c1 和 c2 的值了，其实在做加法，即 让一个数与另一个数相加时，
我们也不希望在加的过程当中去修改加数本身的值
所以，加const 其实是一种设计上的规范
在实现时：
也需要定义一个临时对象 temp，传入参数为 c1 和 c2，c1 的 m_iX
与 c2 的 m_iX 相加，赋值给 temp 的 m_iX，对于 m_iY 同理 … 最后
将temp 作为返回值返回出去
在使用时：
使用时，其实和成员函数的加号 + 运算符重载是一样的，仍然要定义
3 个Coordinate 的对象 coor1、coor2、coor3，将 coor1 与 coor2
相加的和赋值给 coor3，其实就相当于调用 operator+(coor1,coor2)
（2）输出符号 << 的重载
将输出符号 << 的重载声明为友元函数 operator<<()，它的返回值
必须是ostream&，它的第一个参数也必须是一个ostream 的引用，
第二个参数是要进行输出的对象或引用（引用效率更高）
在实现时：
将 ostream 的对象引用 out 替代原来写成 cout 的位置，其他写法不变，
分别输出m_iX 和 m_iY 的值，并一定要将 out 作为返回值返回出去
在使用时：
定义一个 Coordinate 的对象 coor，通过 cout 就可以直接输出 coor 的
m_iX 和 m_iY，如果不进行运算符重载，这样写肯定是错误的，进行运算
符重载之后，这样写就相当于operator<<(cout,coor)
通过这个例子，从侧面也能看出： cout 其实就是一个对象，并且是一个
ostream 类型的对象
那么，输出运算符可以采用成员函数进行重载吗？
从成员函数重载的特点说起：
如果使用成员函数重载，如：上面的加号+ 运算符的重载，传入的
只有一个参数，这个参数其实是第二个加数，第一个加数默认就是
隐形的this 指针，即 当前对象
可是，对于输出运算符来说，第一个参数必须是ostream 的引用，
这就意味着第一个参数不能是隐形的this 指针，二者是相冲突的
所以，当重载输出运算符 << 时，绝对不可以通过成员函数进行
重载，必须使用友元函数进行重载
（3）索引符号 [] 的重载
索引运算符 [] 更多的运用在数组上，这里先运用到Coordinate 类中：
在声明时，将之作为一个成员函数放在类中，定义方法：operator[]()
因为它是索引，所以要传入一个int 型的变量作为索引，而返回值
要么是m_iX，要么是 m_iY
在实现时：
判断传入的index 参数：
如果等于 0，就将 m_iX 作为返回值返回出去，如果等于 1，就将 m_iY
作为返回值返回出去，如果是其他值，暂不处理，实际上应该抛出异常
在使用时：
定义一个Coordinate 的对象 coor，如果通过 cout 输出 coor 的
0 号元素，即 输出横坐标 m_iX，如果输出 coor 的 1 号元素，即
输出纵坐标 m_iY
当调用 coor 接索引时，其实就相当于调用 coor.operator[]()
那么，索引运算符可以采用友元函数进行重载吗？
答案是否定的，不能采用友元函数进行重载。原因是友元函数重载，
它的第一个参数可以是成员函数重载中的隐形this 指针，也可以是
其它值
但作为索引运算符来说，它的第一个参数必须是this 指针，因为
只有第一个参数是this 指针，才能够传入索引，并使得这个索引
所表达的是当前对象中的数据成员
所以，索引运算符必须采用成员函数进行重载，无法使用友元函数
进行重载
程序：
Coordinate.h：
#ifndef COORDINATE_H
#define COORDINATE_H
#include <iostream>
using namespace std;
class Coordinate
{
//+号运算符的友元函数重载与注释掉的成员函数重载做对比
//可以给参数加const 毕竟在做加法运算时不希望加数出现变化
friend Coordinate operator+(Coordinate &c1, Coordinate &c2);
//输出运算符重载只能是友元函数重载
//因为其传入的第一个参数必须是ostream的一个引用（引用的名字任意只要合法）
//
//而根据成员函数重载的特点传入的第一个参数
//是this指针（隐形）也就是当前对象二者相冲突所以只能是友元函数重载
//
//第二个参数是要输出的一个对象或者引用（引用效率更高）
//可以加它一个const 即const Coordinate coor;
//返回值必须是ostream 加一个引用 &
friend ostream &operator<<(ostream &output, Coordinate &coor);
public:
Coordinate(int x, int y);
//+号运算符的成员函数重载返回值是一个Coordinate的对象
//第一个参数是当前的对象也就是隐形的this指针（第一个操作数）
//第二个就是这里明面上的引用（第二个操作数）
//
//即默认第一个加数是当前对象第二个加数是传入的参数
//可以给参数加const 毕竟在做加法运算时不希望加数出现变化
//
//Coordinate operator+(Coordinate &c);
//索引运算符只能是成员函数重载因为友元函数重载的第一个参数
//可以是成员函数重载中的那个this指针也可以是其他的值
//
//但作为索引运算符来说它的第一个参数必须是this指针
//因为只有第一个参数是this指针才能够传入索引
//才能够使得这个索引表达的是当前这个对象中的成员
//
//在这个例子中第一个参数一定是this指针它表达是Coordinate的一个对象
//接下来传入的0或者是1：
//所表达的就是这个传入的this指针所指向的对象当中的0号元素或者1号元素
//所谓0号元素就是当前对象的X值所谓1号对象就是当前对象的Y值
//所以只能采用成员函数进行重载
intoperator[](int index);
int getX();
int getY();
private:
int m_iX;
int m_iY;
};
#endif
Coordinate.cpp：
#include"Coordinate.h"
#include <ostream>
Coordinate::Coordinate(int x, int y)
{
m_iX = x;
m_iY = y;
}
int Coordinate::getX()
{
return m_iX;
}
int Coordinate::getY()
{
return m_iY;
}
//Coordinate Coordinate::operator+(Coordinate &c)
//{
// //先定义一个临时的对象temp 并初始化
// Coordinate temp(0, 0);
// //当前对象（即this指针）和传入的对象横坐标相加
// temp.m_iX = this->m_iX + c.m_iX;
// temp.m_iY = this->m_iY + c.m_iY;
// return temp;
//}
Coordinate operator+(Coordinate &c1, Coordinate &c2)
{
Coordinate temp(0, 0);
temp.m_iX = c1.m_iX + c2.m_iX;
temp.m_iY = c1.m_iY + c2.m_iY;
return temp;
}
//因为使用了ostream类在头文件要包含 #include<ostream>
ostream &operator<<(ostream &output, Coordinate &coor)
{
//注意这里就不需要getX()和getY()了
//因为这里是友元可以直接访问其数据成员
output << coor.m_iX << "," << coor.m_iY;
//返回的是ostream类型的对象
return output;
}
//注意返回类型是int型
int Coordinate::operator[](int index)
{
if (0 == index)
{
return m_iX;
}
if (1 == index)
{
return m_iY;
}
//如果既不是0 也不是1 就应该抛出异常
}
main.cpp：
#include"stdlib.h"
#include"Coordinate.h"
int main(void)
{
Coordinate coor1(1, 3);
Coordinate coor2(2, 4);
Coordinate coor3(0, 0);
//coor3 = coor1 + coor2;//coor3 = coor1.operator+(coor2);
coor3 = coor1 + coor2;//coor3 = operator+(coor1,coor2);
cout << coor3.getX() << "," << coor3.getY() << endl;
//operator<<(cout,coor3);
//由此可知 cout实际上是一个对象是一个ostream类型的对象
cout << coor3 << endl;
cout << coor3[0] << endl;//coor.operator[](0);
cout << coor3[1] << endl;//coor.operator[](1);
system("pause");
return0;
}
【made by siwuxie095】
