二元运算符重载

------------------siwuxie095

   

   

   

   

   

   

   

   

二元运算符重载

   

   

所谓 二元运算符，即 这个符号与两个操做数进行运算

   

   

   

   

   

（1）加号 + 的重载

   

   

   

加号 + 的重载方式有两种：一种是友元函数重载，一种是成员函数重载

   

   

   

1）先来当作员函数重载，以下：

   

定义一个坐标类：Coordinate

   

   

   

在类中声明成员函数 operator+()，它的参数是 const Coordinate &coor

   

   

   

在实现时：

   

   

   

首先须要定义一个临时对象 temp，传入对象 coor 的 m_iX 要和

当前对象的 m_iX 相加，赋值给临时对象 temp 的 m_iX，而对于

m_iY 同理 … 最后将 temp 做为返回值返回出去

   

   

   

在使用时：

   

   

   

定义 3 个 Coordinate 的对象 coor一、coor二、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 的对象 coor一、coor二、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值 //因此只能采用成员函数进行重载 int operator[](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"); return 0; }

   

   

   

   

   

   

   

   

   

【made by siwuxie095】