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

成员运算符重载函数

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

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
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
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@();		//显式调用