C++ 运算符重载

1.运算符重载的意义

运算符重载是C++的一种多态形式，允许赋予C++运算符更多的含义，例如使用“+”实现两个对象的相加，通过运算符重载，隐藏了内部的实现，突出重点，使得代码看起来更加自然。

C++运算符重载是通过操作数的数目和类型选择具体的操作形式。

2.类运算符重载

这里主要介绍类的运算符重载。

（1）运算符重载函数形式

返回值 operator+(操作数)

+可以替换为需要重载的运算符形式，operator+可以理解为函数名，这样整个运算符重载函数和普通的函数就一样。

（2）运算符重载函数是否作为成员函数

运算符重载函数可以作为类的成员函数函数，此时运算符的左边对象是调用对象，运算符的右边对象是作为参数传递的对象，由于调用对象可以使用this指针传递数据，因此运算符重载函数作为类的成员函数时可以省略一个操作数。

例如在复数类Complex中重载运算符“+”。

Complex Complex::operator+(const Complex &c) const
{
	Complex sum;
	sum.real = this->real + c.real;
	sum.imag = this->imag + c.imag;
	return sum;
}

这里有一个比较容易产生疑惑的地方，就是类的对象不能直接访问类的私有变量，但是上述代码中，类的对象sum直接访问了私有变量real和imag（类的声明参见第三部分代码实例）。这是因为该函数是类的成员函数，在类的成员函数中，定义的类对象，或者作为参数的同类对象和this指针是能够直接访问类的私有成员的。因为现在是在定义类的成员函数，没有在使用对象。（参考链接https://blog.csdn.net/geophyboy/article/details/14119775?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task） 友元函数同理。

运算符重载函数也可是非成员函数，此时一个问题是非成员函数中无法通过对象访问类的私有变量，解决的方法是在类的声明中将重载函数指定为友元函数，此时便能够访问类的私有变量。由于此时重载函数不是类的成员，因此无法使用this指针，因此操作数无法省略，并且第一个操作数对应运算符左边，二个操作数对应于运算符右边。由于vs编译器的原因，要求将友元函数的定义写在类的声明中，不然报错（我之前将友元函数的定义和声明分开在两个文件，程序老是报错，根据网上资料，修改后可以正常运行）。

friend istream & operator>>(istream &i, Complex &c)
	{
		using std::cout;
		using std::endl;
		cout << "real:" << endl;
		i >> c.real;
		cout << "imag:" << endl;
		i >> c.imag;
		return i;
	}

注意的是，对于输入输出流符号的重载，输入参数和返回参数都是流对象的引用。原因如下（C++primer plus第六版）

注意，返回引用时，不能返回函数局部变量的引用，因为这个引用在函数结束时会销毁，实际上并没有返回的内容。返回引用，一个返回函数参数传递进来的同类型引用，另一个在成员函数中返回*this。 

3.代码实例

以《C++primer》第六版11章编程题7为例，定义了一个复数类Complex，重载将“+”、“-”，“*”，“*”，“~”重载为复数加法、复数减法、复数乘法、复数与实数乘法、复数共轭等运算，将输入输出流重载为输入输出复数的形式。部分重载函数作为类的成员函数，部分重载函数则是作为友元函数。

Comlex0.h文件

#include <ostream>
#include <istream>
#include <iostream>
using namespace std;
class Complex//定义复数类
{
private:
	double real;
	double imag;
public:
	Complex(double x = 0.0, double y = 0.0);
	//运算符重载
	Complex operator+(const Complex &c) const;
	Complex operator-(const Complex &c) const;
	Complex operator*(const Complex &c) const;
	Complex operator~() const;
	friend Complex operator*(const double &r, const Complex &c);
	friend ostream & operator<<(ostream &o,  Complex &c);
	friend istream & operator>>(istream &i, const Complex &c);
	friend istream & operator>>(istream &i, Complex &c)
	{
		using std::cout;
		using std::endl;
		cout << "real:" << endl;
		i >> c.real;
		cout << "imag:" << endl;
		i >> c.imag;
		return i;
	}
	friend ostream & operator<<(ostream &o, const Complex &c)
	{
		if (c.imag<0)
			o << c.real << c.imag << 'i' << endl;
		else
			o << c.real <<'+'<< c.imag << 'i' << endl;
		return o;
	}
	friend Complex operator*(const double &r, const Complex &c)//复数与实数乘法重载
	{
		Complex num_multiple;
		num_multiple.real = r * c.real;
		num_multiple.imag = r * c.imag;
		return num_multiple;
	}
};

complex.cpp文件

#include "complex0.h"

Complex::Complex(double x, double y)
{
	real = x;
	imag = y;
}

Complex Complex::operator+(const Complex &c) const
{
	Complex sum;
	sum.real = this->real + c.real;
	sum.imag = this->imag + c.imag;
	return sum;
}
Complex Complex::operator-(const Complex &c) const
{
	Complex sub;
	sub.real = this->real - c.real;
	sub.imag = this->imag - c.imag;
	return sub;
}
Complex Complex::operator*(const Complex &c) const
{
	Complex multiple;
	multiple.real = this->real*c.real - this->imag*c.imag;
	multiple.imag = this->real*c.imag + this->imag*c.real;
	return multiple;
}
Complex Complex::operator~() const
{
	Complex conj;
	conj.real = this->real;
	conj.imag = -this->imag;
	return conj;
}

主函数

Complex a(2.3, 4.5);
	Complex c;
	cout << "enter real part and imag part:" << endl;
	cin >> c;
	cout << "a+c=" << a + c << endl;
	cout << "a-c=" << a - c << endl;
	cout << "a*c=" << a * c << endl;
	cout << "conj a=" << ~a << endl;
	cout << "2*a=" << 2 * a << endl;

运行结果

a=2.3+4.5i

c=2.5-5.6i