运算符重载

所谓重载，就是重新赋予新的含义。函数重载是对一个已有的函数赋予新的含义，使之实现新功能。

其实运算符也可以重载，实际上，我们常常在不知不觉之中使用了运算符重载。

运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。

也就是说，运算符重载是通过定义函数实现的。运算符重载实质上是函数的重载。

 

重载运算符的函数一般格式如下：

函数类型 operator 运算符名称（形参列表）

{

        对运算符的重载处理

}

例如我们可以重载运算符“+”，如下：

int operator+ (int a, int b)
{
	return (a - b);
}

ps：我在写的时候，结果提示出现了一个错误：非成员运算符要求类类型或枚举类型的参数，这个原因是假如这样可行的话，如果你所在的团队几个人分工写代码，本来各自代码部分都能正常运行，结果一拼接起来，由于你这样的要求，改变了别人写的函数的本意，例如double fuction(double a,double b) {return a+b;}结果返回了0，你的队友一定会打死你的。所以，为了你的生命安全，C++标准委员会禁止了这样的做法。

举个例子：实现复数加法

-(3,4i)+(5,-10i)=(8,-6i)

#include <iostream>

class Complex
{
public:
	Complex();
	Complex(double r, double i);
	Complex complex_add(Complex &d);
	void print();

private:
	double real;
	double imag;
};

Complex::Complex()
{
	real = 0;
	imag = 0;
}

Complex::Complex(double r, double i)
{
	real = r;
	imag = i;
}

Complex Complex::complex_add(Complex &d)
{
	Complex c;
	c.real = real + d.real;
	c.imag = imag + d.imag;

	return c;
}

void Complex::print()
{
	std::cout << "(" << real << "," << imag << "i)" << std::endl;
}

int main()
{
	Complex c1(3, 4), c2(5, -10), c3;

	c3 = c1.complex_add(c2);

	std::cout << "c1 = ";
	c1.print();
	std::cout << "c2 = ";
	c2.print();
	std::cout << "c1 + c2 = ";
	c3.print();

	return 0;
}

下面用重载的方法：

#include <iostream>

class Complex
{
public:
	Complex();
	Complex(double r, double i);
	Complex operator+(Complex &d);
	void print();

private:
	double real;
	double imag;
};

Complex::Complex()
{
	real = 0;
	imag = 0;
}

Complex::Complex(double r, double i)
{
	real = r;
	imag = i;
}

Complex Complex::operator+(Complex &d)
{
	Complex c;

	c.real = real + d.real;
	c.imag = imag + d.imag;

	return c;
}

void Complex::print()
{
	std::cout << "(" << real << "," << imag << "i)" << std::endl;
}

int main()
{
	Complex c1(2, 3), c2(3, 4), c3;
	std::cout << "c1 = ";
	c1.print();
	std::cout << "c2 = ";
	c2.print();
	c3 = c1 + c2;
	std::cout << "c1 + c2 = ";
	c3.print();
	
	return 0;
}

这里面有一个Complex complex_add(Complex &d)，关于这一句，小甲鱼讲最好不用int，直接用这个函数的类型，然后下面对于这个函数的定义的时候写的是Complex Complex::operator+(Complex &d)，这里有一点不理解，那个::为啥不是在第一个Complex的后面，百度知道有个回答是这样的https://zhidao.baidu.com/question/548108829.html。

其实我们还可以对运算符重载函数operator+改写得更简练一些：

一些规则

C++不允许用户定义新的运算符，只能对已有的C++运算符进行重载

除了以下五个不允许重载外，其他运算符都允许重载：

1：.  成员访问运算符

2：.* 成员指针访问运算符

3：:: 域运算符

4：sizeof 尺寸运算符

5： ?: 条件运算符

重载不能改变运算符对象（操作数）个数

重载不能改变运算符的优先级别

重载不能改变运算符的结合性

重载运算符的函数不能有默认的参数

重载的运算符必须用户定义的自定义类型的对象一起使用，其参数至少应该有一个是类对象或类对象的引用。（也就是说，参数不能全部都是C++的标准类型，这样约定是为了防止用户修改用于标准类型结构的运算符性质）。

疑问

上面写了重载不能改变运算符对象（操作数）个数，可是上面的的程序里面对于“+”的重载为什么只有一个参数呢？

解答

实际上，运算符重载函数有两个参数，但由于重载函数是Complex类中的成员函数，有一个参数时隐含着的，运算符函数是用this指针隐式地访问类对象的成员。实际的过程如下：

return Complex(real + c2.real, imag + c2.imag)

return Complex(this->real + c2.real, this->imag + c2.imag)

return Complex(c1.real + c2.real, c1.imag + c2.imag)

那么例子中的c1 + c2，编译系统会把它解释为：

c1.operator+(c2)，实际上是调用了c1的一个成员函数。

扩展

运算符重载函数除了可以作为类的成员函数外，还可以是非成员函数：放在类外，这里就要用到友元函数。

#include <iostream>

class Complex
{
public:
	Complex();
	Complex(double r, double i);
	friend Complex operator+(Complex &c1, Complex &c2);
	void print();

private:
	double real;
	double imag;
};

Complex::Complex()
{
	real = 0;
	imag = 0;
}

Complex::Complex(double r, double i)
{
	real = r;
	imag = i;
}
 //注意，这里作为友元函数，不属于Complex，记得别写：：咯！
Complex operator+(Complex &c1, Complex &c2)
{
	return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

void Complex::print()
{
	std::cout << "(" << real << "," << imag << "i)" << std::endl;
}

int main()
{
	Complex c1(2, 3), c2(3, 4), c3;
	std::cout << "c1 = ";
	c1.print();
	std::cout << "c2 = ";
	c2.print();
	c3 = c1 + c2;
	std::cout << "c1 + c2 = ";
	c3.print();
	
	return 0;
}

为什么把运算符函数作为友元函数呢？

因为运算符函数要访问Complex类对象的成员，如果运算符函数不是Complex类的友元函数，而是一个普通的函数，它是没有权力访问Complex类的私有成员的。

由于友元的使用会破坏类的封装，因此从原则上说，要尽量将运算符函数作为成员函数。