C++运算符重载和operator函数重载

主要有三种情况：①运算符重载 ②operator函数重载 ③operator函数是类的友元

运算符重载

对已有的运算符重新定义，赋予另一种功能。运算符的重载一般是在类中定义的，这样就可以在该类中使用已重载的运算符进行相应的操作。这里利用了一个函数　operator（）函数，一般定义的时候：

函数返回类型 operator（要重载的运算符）(参数列表)；//这是声明
//例如：
//假设有一个类，名为A
A operator
+(A &a);//重载运算符“+”，此处是函数声明；
A A::operator+(A &a){   //这是具体定义
  ...
}//第一个A是函数返回类型，第二个A是该函数属于A类，第三个A是函数形参类型。

在operator+()函数中可以自动得到指向当前对象的this指针，因此只需要运算的另一个参数即可。可以调用该函数或者直接使用重载后的运算符。

c=a.operator(b) //当前对象为a,传入参数为对象b,返回值存到c中
c=a+b  //直接使用重载后的运算符操作，两者等价

下面举一个复数相加的例子

#include<iostream>
using namespace std;

class complex {
public:
	int a; //实部
	int b; //虚部
public:
	complex() {};
	complex(int x, int y) :a(x), b(y) {};
	//+运算符重载
	complex operator+(complex x) {
		complex temp;
		temp.a = this->a + x.a;
		temp.b = this->b + x.b;
		return temp;
	}
	void show();
};
void complex::show()
{
	cout << a << "+" << b << "i" << endl;
}
int main()
{
	complex a(1, 2);//调用变换构造函数
	complex b(3, 1);//调用变换构造函数
	complex c; //调用默认构造函数
	c = a + b;
	//也可以用调用函数的方式
	//c = a.operator+(b);
	c.show(); //
	return 0;
}

同理，可以实现复数的减法，乘法等。

operator函数重载

上面我们的operator函数的功能是实现两个对象的运算。假如我们想要实现一个对象和别的数据类型的运算，那么就要实现operator函数的重载。例如：c = a + 2; 其中a,c都是对象；
举个例子，有一个学生类，数据成员是age,希望能直接运算他的年龄并赋值给别的对象。

#include<iostream>
using namespace std;

class student{
	public:
		int age;
	public:
		student(){};
		student(int t_age):age(t_age){};
		student operator+(int increment);
		void show_age()
		{
			cout<<"age = "<<age<<endl;
		}
}; 
student student::operator+(int increment)
{
	student stu;
	stu.age = this->age + increment;
	return stu;
	//注意这里不能返回引用，因为stu是局部对象（临时变量），当函数调用结束之后，就会被销毁，不会被存储在内存中，也就不存在地址。返回引用/指针将会报错。
}
int main()
{
	student stu(10);
	student stu2;
	stu2 = stu + 20;
	stu2.show_age(); //age = 30 
//当然也可以进行自加运算
	stu = stu + 20;
//但是不能这样，因为没有重载 += 运算符

	return 0;
}

假如此处不想赋值给别的对象，只是修改自己本身的年龄，那么operator函数应该这样写：

void operator+(int increment); //函数声明
void student::operator+(int increment)
{
	this->age += increment;
}

//函数调用
student stu(10);
stu.operator+(10); //只能直接调用
//stu + 10; //不能用+,因为没有返回值

operator函数是类的友元

如果将operator函数定义为类的成员函数，那么就算重载之后运算符的左边也只能是对象，而不能是数值。为了能够进行类似c=2+a的运算，其中a,c都是对象。可以把operator函数定义为类的友元函数。当operator函数声明为一个类的友元之后，那么该函数就可以操作类中的数据。
例如：

#include<iostream>
using namespace std;

class student{
	public:
		int age;
	public:
		friend student operator+(int increment,student x); //声明友元函数
		student(){};
		student(int t_age):age(t_age){};
		void show_age()
		{
			cout<<"age = "<<age<<endl;
		}
}; 
//友元函数实现，注意这不是类的成员函数
student operator+(int increment,student x)
{
	student temp;
	temp.age = x.age + increment;
	return temp;
}

int main()
{
	student stu(10);
	student stu2;
	stu2 = 20 + stu; //调用operator函数
	stu2.show_age(); //age = 30 
	return 0;
}

注意：当将operator函数作为友元函数时，应该保证有一个参数至少是类的对象，否则若两个参数都是数值2+3就无法判断是正常的2+3还是调用这里的函数operator+(2,3)；将会出现编译错误。

总结

①运算符重载是为了实现两个对象之间直接运算； c = a + b;
②operator函数重载是为了一个对象可以直接和别的数据类型进行运算：c = a + 2;
③将operator函数声明为类的友元是为了别的数据类型能和一个对象直接运算： c = 2 + a;