之前学习了类的函数重载的概念，今天学习操作符重载的概念。在这之前我们先看一个例子：

上面是一个复数的加法，a为复数的实部，b为复数的虚部，在main函数里我想实现复数c1与c2的加法。很显然，正常的+号操作符是不能实现复数的相加减的。那么我们可以添加功能函数实现让两个复数的相加减的。代码如下：

#include <stdio.h>

class Complex
{
        int a;
        int b;
public:
        Complex(int a = 0,int b = 0)
        {
                this->a = a;
                this->b = b;
        }
        int getA()
        {
                return a;
        }
        int getB()
        {
                return b;
        }
        friend Complex Add(const Complex& p1,const Complex& p2);
};

Complex Add(const Complex& p1,const Complex& p2)
{
        Complex ret;
        
        ret.a = p1.a + p2.a;
        ret.b = p1.b + p2.b;
        
        return ret;
}

int main()
{
        Complex c1(1,2);
        Complex c2(3,4);
        Complex c3 = Add(c1,c2); //c1 + c2
        
        printf("c3.a = %d,c3.b = %d\n",c3.getA(),c3.getB());
      
        return 0;
}

打印如下：

c3.a = 4,c3.b = 6

说明程序实现了两个复数相加减的功能。
上面的Add函数解决了Complex对象的相加减的问题，但是Complex是现实世界中确实存在的复数，并且复数在数学中的地位与普通的实数相同。
为什么不能让 + 号这个操作符也支持复数相加呢？
由此我们你就想到了一个概念，操作符重载的概念：

  • C++中的重载能够扩展到操作符的功能
  • 操作符的重载以函数的方式进行

本质：

  • 用特殊形式的函数扩展操作符的功能

操作符重载的用法：

  • 通过operator关键字可以定义特殊函数
  • operator的本质是通过函数重载操作符

语法：

Type operator Sign(const Type& p1, const Type& p2)
{
	Type ret;


	return ret;
}

其中Sign为系统中预定义的操作符，如：+，- ，* ，/，等
将上面的程序改写为：

#include <stdio.h>

class Complex
{
        int a;
        int b;
public:
        Complex(int a = 0,int b = 0)
        {
                this->a = a;
                this->b = b;
        }
        int getA()
        {
                return a;
        }
        int getB()
        {
                return b;
        }
        friend Complex operator +(const Complex& p1,const Complex& p2);
};

Complex operator +(const Complex& p1,const Complex& p2)
{
        Complex ret;
        
        ret.a = p1.a + p2.a;
        ret.b = p1.b + p2.b;
        
        return ret;
}

int main()
{
        Complex c1(1,2);
        Complex c2(3,4);
        Complex c3 = c1 + c2; //operator +(c1,c2)
        
        printf("c3.a = %d,c3.b = %d\n",c3.getA(),c3.getB());
        
        
        return 0;
}

运行结果为：

c3.a = 4,c3.b = 6

这说明，我们的修改是对的，我们已经解决了这个复数相加的问题。

但是我们上述的程序都用到了友元的概念，但是友元一般不会出现在现代软件工程中。所以我们还可以改进：

  • 可以将操作符重载函数定义为类的成员函数
  • 比全局操作符重载函数少一个参数（左操作数）
  • 不需要依赖友元就可以实现操作符重载
  • 编译器优先在成员函数中寻找操作符重载函数

看如下代码：

#include <stdio.h>

class Complex
{
        int a;
        int b;
public:
        Complex(int a = 0,int b = 0)
        {
                this->a = a;
                this->b = b;
        }
        int getA()
        {
                return a;
        }
        int getB()
        {
                return b;
        }
        Complex operator +(const Complex& p)
        {
        Complex ret;
        printf("Complex operator +(const Complex& p)\n");
        ret.a = this->a + p.a;
        ret.b = this->b + p.b;
        
        return ret;
        }
        friend Complex operator +(const Complex& p1,const Complex& p2);
};

Complex operator +(const Complex& p1,const Complex& p2)
{
        Complex ret;
        printf("Complex operator +(const Complex& p1,const Complex& p2)\n");
        ret.a = p1.a + p2.a;
        ret.b = p1.b + p2.b;
        
        return ret;
}

int main()
{
        Complex c1(1,2);
        Complex c2(3,4);
        Complex c3 = c1 + c2; //c1.operator + (c2)
        
        printf("c3.a = %d,c3.b = %d\n",c3.getA(),c3.getB());
        
        
        return 0;
}

运行结果为：

Complex operator +(const Complex& p)
c3.a = 4,c3.b = 6

分析运行结果以及程序：

运行结果打印的Complex operator +(const Complex& p)，说明编译器优先在成员函数中寻找操作符重载函数，而没有选择全局变量中的重载函数。计算结果正常，说明可以将操作符重载函数定义为类的成员函数。
程序中类的成员重载函数Complex operator +(const Complex& p)，只有一个参数，少一个参数。并且c1 + c2 等同于：c1.operator + (c2)。

总结：

  • 操作符重载是C++强大的特性之一
  • 操作符重载的本质是通过函数扩展操作符的功能
  • operator关键字是实现操作符的关键
  • 操作符重载遵循相同的函数重载法则
  • 全局函数和成员函数都可以实现对操作符的重载

想获得各种学习资源以及交流学习的加我（有我博客中写的代码的原稿）：
qq：1126137994
微信：liu1126137994
可以共同交流关于嵌入式，操作系统，C++语言，C语言，数据结构等技术问题。