运算符的重载

将运算符重载为类的成员函数，一般形式为：

class 类名{ //类体
　　　………
　　返回类型 operator 运算符号（形式参数列表）
　　{
　　 　　　函数体
　　}
　　……
}；

当运算符重载为成员函数时，运算符函数的形式参数的个数比运算符规定的运算对象个数少一个。
因为是类的非静态成员函数都有一个隐含的this指针，运算符函数可以用this指针隐式的访问类对象的成员，因此这个对象自身的数据可以直接访问，不需要放到形参列表中进行传递，少了的运算对象就是该对象本身
1.双目运算符重载为类的成员函数，形式如下
返回类型 类名：：operator op（const 所属类型 &obj2）
{
…… //this指针对应obj1运算对象
}
经过重载后，表达式“obj1 op obj2"
相当于 obj1.operator op(obj2)
实例代码如下：

#include <iostream>
using namespace std;

class complex //复数类
{
	public:
		complex(double r = 0.0, double i = 0.0){ real = r; imag = i; }//构造函数
		complex operator +(complex &c2); //重载+运算符
		complex operator -(complex &c2);  //重载-运算符
		void display()
		{
			cout << real << "+" << imag << "i" << endl;
		}
	private:
		double real;  //实部
		double imag;//虚部
};
complex complex::operator +(complex &c2)
{
	complex c;
	c.real = c2.real + real;
	c.imag = c2.imag + imag;
	return c;
}
complex complex::operator -(complex &c2)
{
	complex c;
	c.real = real - c2.real;   //顺序不能颠倒
	c.imag = imag - c2.imag;
	return c;
}

int main()
{
	complex c1(1, 2), c2(3, 4), c3;
	c3 = c2 + c1; c3.display(); //输出4+6i
	c3 = c2 - c1; c3.display(); //输出2+2i

	system("pause");
	return 0;
}

2.前置单目运算符重载为类的成员函数，形式如下：
返回类型 类名：：operator op()
{
……//this指针对应obj运算对象
}
经过重载后，表达式 ”op obj"
相当于obj.operator op()

实例代码如下：

#include <iostream>
using namespace std;

class complex //复数类
{
	public:
		complex(double r = 0.0, double i = 0.0){ real = r; imag = i; }//构造函数
		complex operator ++(); //重载前置++
		void display()
		{
			cout << real << "+" << imag << "i" << endl;
		}
	private:
		double real;//实部
		double imag;//虚部
};
complex complex::operator ++()
{
	complex a;
	real++;
	imag++;
	a.real = real;
	a.imag = imag;
	return a;
}

int main()
{
	complex c1(1, 2),c2;
	c2 = ++c1;
	c1.display();//输出2+3i
	c2.display();//输出2+3i

	system("pause");
	return 0;
}

3.后置单目运算符重载为类的成员函数，形式如下：
返回类型 类名：：operator op(int)//参数 int 用来区分前置和后置
{
　　　……//this指针对应obj运算对象
}
经过重载后，表达式 “obj op”
相当于obj.operator op(0)

实例代码如下：

#include <iostream>
using namespace std;

class complex //复数类
{
	public:
		complex(double r = 0.0, double i = 0.0){ real = r; imag = i; }//构造函数
		complex operator ++(); //重载后置++
		void display()
		{
			cout << real << "+" << imag << "i" << endl;
		}
	private:
		double real;//实部
		double imag;//虚部
};
complex complex::operator ++()
{
	complex a;
	a.real = real;
	a.imag = imag;
	real++;
	imag++;
	return a;
}

int main()
{
	complex c1(1, 2),c2;
	c2 = ++c1;
	c1.display();//输出2+3i
	c2.display();//输出1+2i

	system("pause");
	return 0;
}

将运算符重载为友元函数，一般形式为：

class 类名{ //类体
　　　………
　　//友元声明
　　friend 返回类型 operator 运算符号（形式参数列表）;
}；
返回类型 operator 运算符号（形式参数列表）
{
　　 函数体
}
当运算符重载为友元函数时，运算符函数的形式参数的个数和运算符规定的运算对象一致

1.双目运算符重载为类的友元函数，形式如下:
返回类型 operator op(const 所属类型 &obj1,const 所属类型 &obj2）
{
　　　……//obj1和obj2分别对应两个运算对象
}
经过重载后，表达式“obj1 op obj2"
相当于operator op(obj1,obj2)

#include <iostream>
using namespace std;

class complex //复数类
{
	public:
	complex(double r = 0.0, double i = 0.0){ real = r; imag = i; }//构造函数
	friend complex operator +(const complex &c1,const complex &c2); //重载+运算符
	friend complex operator -(const complex &c1,const complex &c2); //重载-运算符
	void display()
	{
		cout << real << "+" << imag << "i" << endl;
	}
	private:
	double real;  //实部
	double imag;//虚部
};
complex operator +(const complex &c1,const complex &c2)
{
	complex c3;
	c3.real = c1.real + c2.real;
	c3.imag = c1.imag + c2.imag;
	return c3;
}
complex operator -(const complex &c1,const complex &c2)
{
	complex c3;
	c3.real = c1.real - c2.real;   //顺序不能颠倒
	c3.imag = c1.imag - c2.imag;
	return c3;
}

int main()
{
	complex c1(1, 2), c2(3, 4), c3;
	c3 = c2 + c1; c3.display(); //输出4+6i
	c3 = c2 - c1; c3.display(); //输出2+2i

	system("pause");
	return 0;
}

2.前置单目运算符重载为类的友元函数，形式如下：
返回类型 operator op(const 所属类型 &obj)
{
　　　…… //obj对应运算对象
}
经过重载后，表达式”op obj2"
相当于operator op(obj)

3.后置单目运算符重载为类的友元函数，形式如下：
返回类型 operator op(const 所属类型 &obj,int )
{
　　　…… //obj对应运算对象
}
经过重载后，表达式”op obj2"
相当于operator op(obj)