运算符重载之成员运算符重载

成员运算符重载函数

成员运算符重载函数，即把运算符重载函数定义为某个类的成员函数。

1、定义成员运算符重载函数的语法形式

（1）在类的内部，定义成员运算符重载函数的格式如下：

函数类型 operator 运算符(形参表){函数体
}

（2）成员运算符重载函数也可以在类中声明成员函数的原型，在类外定义。

在类内，声明成员运算符重载函数原型的格式如下：

class X{函数类型 operator 运算符(形参表);
}

在类外，定义成员运算符重载函数的格式如下：

函数类型 X::operator 运算符(形参表){函数体
}

operator 是定义运算符重载函数的关键字；
运算符即是要重载的运算符名称，必须是 C++中可重载的运算符；
由于成员运算符重载函数是该类的成员函数，所以在类外定义时需要缀上类名。

在成员运算符重载函数的形参表中，若运算符是单目的，则参数表为空；若运算符是双目的，则参数表中有一个操作数。

2、双目运算符重载

对双目运算符而言，成员运算符重载函数的形参表中仅有一个参数，它作为运算符的右操作数。另一个操作数（左操作数）是隐含的，是该类的当前对象，它是通过 this 指针隐含地递给函数的。例如，

class X{```int operator+(X a);```
}

在类 X 中声明了重载 “+” 的成员运算符重载函数，返回类型为 int ，它具有两个操作数，一个是当前对象，另一个是类 X 的对象 a。

例 1：用成员运算符重载函数进行复数运算。

#include<iostream>
using namespace std;
class Complex{private:double real;double imag;public:Complex(double r=0.0,double i=0.0);      //构造函数void print();     //显示输出复数Complex operator+(Complex c);      //声明运算符 "+" 重载函数Complex operator-(Complex c);        //声明运算符 "-" 重载函数Complex operator*(Complex c);     //声明运算符 "*" 重载函数Complex operator/(Complex c);     //声明运算符 "/" 重载函数
};
Complex::Complex(double r,double i){  //构造函数 real=r;imag=i;
}
void Complex::print(){      //显示复数的实数和虚数部分 cout<<real;if(imag>0)cout<<"+";if(imag!=0)cout<<imag<<'i'<<endl;
}
Complex Complex::operator+(Complex c){     Complex temp;temp.real=real+c.real;temp.imag=imag+c.imag;return temp;
}
Complex Complex::operator-(Complex c){      Complex temp;temp.real=real-c.real;temp.imag=imag-c.imag;return temp;
}
Complex Complex::operator*(Complex c){      Complex temp;temp.real=real*c.real-imag*c.imag;temp.imag=real*c.imag+imag*c.real;return temp;
}
Complex Complex::operator/(Complex c){      Complex temp;double t;t=1/(c.real*c.real+c.imag*c.imag);temp.real=(real*c.real+imag*c.imag)*t;temp.imag=(c.real*imag-real*c.imag)*t;return temp;
}
int main(){Complex A1(2.3,4.6),A2(3.6,2.8),A3,A4,A5,A6;A3=A1.operator+(A2);A4=A1-A2;A5=A1*A2;A6=A1/A2;A1.print();A2.print();A3.print();A4.print();A5.print();A6.print();return 0;
}

执行结果：

其中，

A3=A1+A2;

C++ 将其解释为：

A3=A1.operator+(A2);

一般而言，如果在类 X 中采用成员函数重载双目运算符@，成员运算符函数 operator@ 所需的一个操作数由对象 aa 通过 this 指针隐含地传递，它的另一个操作数 bb 在参数表中显示，则以下两种函数调用方法是等价的：

aa@bb;      //隐式调用
aa.operator@(bb);      //显式调用

3、单目运算符重载

对单目运算符而言，成员运算符重载函数的参数中没有参数，此时当前对象作为运算符的一个操作数。

例 2：用成员函数重载单目运算符“++”

#include<iostream>
using namespace std;
class Coord{private:int x,y;public:Coord(int i=0,int j=0);void print();Coord operator++();
};
Coord::Coord(int i,int j){x=i;y=j;
}
void Coord::print(){cout<<"x:"<<x<<",y="<<y<<endl;
}
Coord Coord::operator++(){        //定义运算符++重载函数 operator++ ++x;++y;return *this;  //返回当前对象的值
}
int main(){Coord ob(10,20);ob.print();++ob;ob.print();ob.operator++();ob.print();return 0;
}

执行结果：

本例中主函数 main 中调用成员运算符重载函数 operator++ 的两种方式，

++ob;

和

ob.operator++();

是等价的，其执行效果相同。

一般而言，采用成员函数重载单目运算符时，以下两种方法是等价：

@aa;    //隐式调用
aa.operator@();        //显式调用