从「+」开始，掌握运算符重载的六脉神剑

运算符重载

运算符重载的介绍

C++ 预定义中的运算符的操作对象只局限于基本的内置数据类型，但是对于自定义的类型是没有办法操作的。当然我们可以定义一些函数来实现这些操作，但考虑到用运算符表达含义的方式很简洁易懂，当定义了自定义类型时，也希望这些运算符能被自定义类类型使用，以此提高开发效率，增加代码的可复用性。为了实现这个需求，C++提供了运算符重载。其指导思想是：希望自定义类类型在操作时与内置类型保持一致。

能够重载的运算符有42个

+	-	*	/	%	^
&	|	~	!	=	<
>	+=	-=	*=	/=	%=
^=	&=	|=	>>	<<	>>=
<<=	==	!=	>=	<=	&&
||	++	--	->*	->	,
[]	()	new	delete	new[]	delete[]

不能重载的运算符包括

记法：带点的运算符不能重载，加上sizeof

运算符重载的规则与形式（重点）

• 运算符重载有以下规则

1. 运算符重载时 ，其操作数类型必须要是自定义类类型或枚举类型 ——不能是内置类型

2. 其优先级和结合性还是固定不变的 a == b + c

3. 操作符的操作数个数是保持不变的

4. 运算符重载时 ，不能设置默认参数 ——如果设置了默认值，其实也就是改变了操作数的个数

5. 逻辑与 && 逻辑或 || 就不再具备短路求值特性 ，进入函数体之前必须完成所有函数参数的计算, 不推荐重载

6. 不能臆造一个并不存在的运算符 （只有内置类型所存在的运算符才可以进行重载） @ $ 、

• 运算符重载的形式

运算符重载的形式有三种：

1. 采用友元函数的重载形式

2. 采用普通函数的重载形式

3. 采用成员函数的重载形式

以加法运算符为例，认识这三种形式。

+运算符重载

需求：实现一个复数类，复数分为实部和虚部，重载+运算符，使其能够处理两个复数之间的加法运算（实部加实部，虚部加虚部）

友元函数实现

我们可以定义一个普通函数，接收两个复数类对象，在这个函数中定义计算逻辑。因为要在类外访问Complex的私有成员，故可以将这个普通函数设为Complex的友元函数

class Complex{
    //...
    friend Complex add(const Complex & lhs, const Complex & rhs);
    //...
};

Complex add(const Complex & lhs, const Complex & rhs){
    //...
}

void test0(){
    Complex cx(1,2);
    Complex cx2(3,4);
    Complex cx3 = add(cx,cx2); //这样就可以计算两个Complex对象的加法了
}

还想要更直观、更简洁一些，那么可以定义一个相应的运算符重载函数（operator+），就可以直接使用+完成这两个对象的加法运算了

class Complex{
    //...
    friend Complex operator+(const Complex & lhs, const Complex & rhs);
    //...
};

Complex operator+(const Complex & lhs, const Complex & rhs){
    //...
}

void test0(){
    Complex cx(1,2);
    Complex cx2(3,4);
    Complex cx3 = cx + cx2; //看上去和内置类型的计算一样了
    //Complex cx3 = operator(cx,cx2);   //本质上是调用了operator+函数
}

下面为测试代码，就可以自行测试

#include<iostream>
using namespace std;

class complex{
    public:
    complex(int real,int image)
    :_real(real)
    ,_image(image)
    {}
    void print () const
    {
        cout << _real <<"+" << _image <<"i" << endl;
    }

    friend complex operator +(const complex &rhs,const complex &lhs);
  
    private:
    int _real;
    int _image;
};

//当我要写一个函数时要考虑要对什么进行操作，操作的参数是什么，返回值是什么,
//为普通函数不可以访问类的私有成员，将函数在类中声明为友元
complex operator +(const complex &rhs,const complex &lhs)
{
    return complex(rhs._real + lhs._real,rhs._image+lhs._image);
}

void test0()
{
    complex c1(2,3);
    complex c2(3,5);
    //会调用默认的拷贝构造
    complex c3 = c1 + c2;
    c3.print();

}
int main()
{
    test0();
    return 0;
}

运算符重载的本质是定义一个运算符重载函数，步骤如下

1. 先确定这个函数的返回值是什么类型（加法运算返回值应该是一个临时的Complex对象，所以此处返回类型为Complex）

2. 再写上函数名（operator + 运算符，此处就是operator+）

3. 再补充参数列表（考虑这个运算符有几个操作数，此处加法运算应该有两个操作数，分别是两个Complex对象，因为加法操作不改变操作数的值，可以用const引用作为形参）

4. 最后完成函数体的内容（此处直接调用Complex构造函数创建一个新的对象作为返回值）。

——在定义的operator+函数中需要访问Complex类的私有成员，要进行友元声明

像加号这一类不会修改操作数的值的运算符，倾向于采用友元函数的方式重载。

普通函数实现

在一个普通函数中想要访问一个类的私有成员，也可以给这个类添加一些公有的get系列函数，因为这些成员函数是可以访问私有成员的，而在类外可以通过对象直接调用这些成员函数，也就能获取到私有成员了。

实际工作中不推荐使用，因为这样做几乎完全失去了对私有成员的保护。

class Complex {
public:
	//...
	double getReal() const { return _real; }
	double getImage() const { return _image; }
	//...
};

Complex operator+(const Complex & lhs, const Complex & rhs)
{
	return Complex(lhs.getReal() + rhs.getReal(),
			lhs.getImage() + rhs.getImage());
}

void test0()
{
	Complex c1(1, 2), c2(3, 4);
	Complex c3 = c1 + c2;//ok
}

成员函数实现

还可以将运算符重载函数定义为Complex类的成员函数

class Complex{
public:
	//...
	Complex operator+(const Complex & rhs)
	{
		return Complex(_real + rhs._real, _image + rhs._image);
	}
};

这种写法要注意的是，加法运算符的左操作数实际上就是this指针所指向的对象，在参数列表中只需要写上右操作数

Complex cp1(1,2);
Complex cp2(3,4);
Complex cp = cp1 + cp2;  //本质是Complex cp = cp1.operator+(cp2)

下面为测试代码，可以自行测试

#include<iostream>
using namespace std;

class complex{
    public:
    complex(int real,int image)
    :_real(real)
    ,_image(image)
    {}
    void print () const
    {
        cout << _real <<"+" << _image <<"i" << endl;
    }
    //这里传一个参数就可以，因为有个this指针，可以找到自己类中成员的值
    complex operator +(const complex &lhs)
    {
        return complex(_real+lhs._real , _image+lhs._image);
    }

    private:
    int _real;
    int _image;
};

void test0()
{
    complex c1(2,3);
    complex c2(3,5);
    //会调用默认的拷贝构造
    complex c3 = c1 + c2;
    c3.print();

    complex c4 = c1.operator+(c2); //本质
    c4.print();

}
int main()
{
    test0();
    return 0;
}

——思考，如果我们写出了这样的代码，是否可以通过呢？ —— 可以通过，但是要避免

class Complex{
public:
	//...
	Complex operator+(const Complex & rhs)
	{
		return Complex(_real - rhs._real, _image - rhs._image);
	}
};

明明是加操作符，但函数内却进行的是减法运算，这是合乎语法规则的，不过却有悖于人们的直觉思维，会引起不必要的混乱。

因此，除非有特别的理由，尽量使重载的运算符与其内置的、广为接受的语义保持一致。