运算符重载
这里写目录标题
-
- 运算符重载
- 在全局范围内重载运算符
- 运算符重载时要遵循的规则
-
- 运算符重载到底以成员函数的形式更好还是全局函数（友元函数）的形式更好
- 重载++
- 例题（属于友元函数的 运算符重载函数）
运算符重载
运算符重载其实就是定义一个函数，在函数体内实现想要的功能，当用到该运算符时，编译器会自动调用这个函数。也就是说，运算符重载是通过函数实现的，它本质上是函数重载。
// complex类内
public:
//声明运算符重载
complex operator+(const complex &A) const;
//实现运算符重载
complex complex::operator+(const complex &A) const{
complex B;
B.m_real = this->m_real + A.m_real;
B.m_imag = this->m_imag + A.m_imag;
return B;
}
运算符重载的格式为：
返回值类型 operator 运算符名称 (形参表列){
//TODO:
}
operator是关键字，专门用于定义重载运算符的函数。我们可以将operator 运算符名称这一部分看做函数名，对于上面的代码，函数名就是operator+。
运算符重载函数除了函数名有特定的格式，其它地方和普通函数并没有区别。
上面的例子中，我们在 complex 类中重载了运算符+，该重载只对 complex 对象有效。当执行c3 = c1 + c2;语句时，编译器检测到+号左边（+号具有左结合性，所以先检测左边）是一个 complex 对象，就会调用成员函数operator+()，也就是转换为下面的形式：
c3 = c1.operator+(c2);
c1 是要调用函数的对象，c2 是函数的实参。
上面的运算符重载还可以有更加简练的定义形式：
complex complex::operator+(const complex &A)const{
return complex(this->m_real + A.m_real, this->m_imag + A.m_imag);
}
return 语句中的complex(this->m_real + A.m_real, this->m_imag + A.m_imag)会创建一个临时对象，这个对象没有名称，是一个匿名对象。在创建临时对象过程中调用构造函数，return 语句将该临时对象作为函数返回值。
在全局范围内重载运算符
运算符重载函数不仅可以作为类的成员函数，还可以作为全局函数。更改上面的代码，在全局范围内重载+，实现复数的加法运算：
//在全局范围内重载+
complex operator+(const complex &A, const complex &B){
complex C;
C.m_real = A.m_real + B.m_real;
C.m_imag = A.m_imag + B.m_imag;
return C;
}
当执行c3 = c1 + c2;语句时，编译器检测到+号两边都是 complex 对象，就会转换为类似下面的函数调用：
c3 = operator+(c1, c2);
完整代码
#include 运算符重载函数不是 complex 类的成员函数，但是却用到了 complex 类的 private 成员变量，所以必须在 complex 类中将该函数声明为友元函数。
运算符重载时要遵循的规则
四则运算符（+、-、、/、+=、-=、=、/=）和关系运算符（>、<、<=、>=、==、!=）都是数学运算符，它们在实际开发中非常常见，被重载的几率也很高，并且有着相似的重载格式。本节以复数类 Complex 为例对它们进行重载，重在演示运算符重载的语法以及规范。
#include 复数能够进行完整的四则运算，但不能进行完整的关系运算：我们只能判断两个复数是否相等，但不能比较它们的大小，所以不能对 >、<、<=、>= 进行重载。
需要注意的是，我们以全局函数的形式重载了 +、-、、/、==、!=，以成员函数的形式重载了 +=、-=、=、/=，而且应该坚持这样做，不能一股脑都写作成员函数或者全局函数
运算符重载到底以成员函数的形式更好还是全局函数（友元函数）的形式更好
C++ 规定，箭头运算符->、下标运算符[ ]、函数调用运算符( )、赋值运算符=只能以成员函数的形式重载。
- 1.全局函数的形式重载 +、-、*、/、==、!=
解释一：C++ 只会对成员函数的参数进行类型转换，而不会对调用成员函数的对象进行类型转换
假设 在成员函数中 对+进行重载
public:
Complex operator+(const Complex& c1)const;
//类外实现
Complex Complex::operator+(const Complex& c1)const {
Complex c3;
c3.m_real = this->m_real + c1.m_real;
c3.m_imag = this->m_imag + c1.m_imag;
return c3;
Complex c1(25, 35);
Complex c2 = c1 + 15.6;
cout <<"c2" << c2.real() << " + " << c2.imag() << "i" << endl;
// Complex c3 = 15.6 + c1;
// cout <<"c3" << c3.real() << " + " << c3.imag() << "i" << endl;
上述代码执行Complex c2 = c1 + 15.6;编译器检测到+号左边（+号具有左结合性，所以先检测左边）是一个 complex 对象，就会调用成员函数operator+()。检测到15.6是一个double。于是自动调用Complex(double real)这个转换构造函数。最后执行成功。
但是如果执行Complex c3 = 15.6 + c1;就会发生错误了，因为 double 类型并没有以成员函数的形式重载 +。
也就是说，以成员函数的形式重载 +，只能计算c1 + 15.6，不能计算15.6 + c1。
全局函数形式重载
public:
friend Complex operator+(const Complex& c1, const Complex& c2);
Complex operator+(const Complex& c1, const Complex& c2) {
Complex c;
c.m_real = c1.m_real + c2.m_real;
c.m_imag = c1.m_imag + c2.m_imag;
return c;
}
C++ 只会对成员函数的参数进行类型转换，而不会对调用成员函数的对象进行类型转换
解释二：
若在成员函数
class Complex
{
double real,imag;
public:
Complex(double r,double i):real(r),imag(i) { };
Complex operator+ (double r);
};
Complex Complex::operator+(double r)
{
return Complex(real + r,imag);
}
可以解释Complex c; c = c + 5,相当于 c=c.operator+(5) 但是不能解释c = 5 + c,所以将运算符重载为普通函数，此时参数个数就是原生运算符的目数，而不是目数减一，但不能访问对象的私有成员，所以要在类中将函数声明为友元函数。
class Complex
{
double real,imag;
public:
Complex(double r,double i):real(r),imag(i) { };
Complex operator+ (double r);
friend Complex operator+ (double r,const Complex & c);
};
Complex Complex::operator+(double r,const Complex & c)
{
return Complex(c.real + r,c.imag);
}
其实就是，为了确定类型吧，当参数个数为运算符目数 ，运算数的顺序无所谓，可以匹配参数进行识别
当参数个数为运算符目数-1，就麻烦了，顺序匹配时ok（重载的类别在前），否则未重载的类别在前就无法进行运算
根据解释一，虽然可以对对象进行类型转换，但只能对 只会对成员函数的参数进行类型转换，而不会对调用成员函数的对象进行类型转换，所以 未重载的类别在前时，重载的对象 即调用成员函数的对象不会进行类型转换
-
- 成员函数的形式重载 +=、-=、*=、/=
因为 += 符号不存在有数据类型颠倒的情况，且
运算符重载的初衷是给类添加新的功能，方便类的运算，所以这类运算符首选用类的成员函数去重载。
参考一
参考二
- 成员函数的形式重载 +=、-=、*=、/=
重载++
stopwatch stopwatch::run(){
++m_sec;
if(m_sec == 60){
m_min++;
m_sec = 0;
}
return *this;
}
stopwatch stopwatch::operator++(){
return run();
}
stopwatch stopwatch::operator++(int n){
stopwatch s = *this;
run();
return s;
}
上面的代码定义了一个简单的秒表类，m_min 表示分钟，m_sec 表示秒钟，setzero() 函数用于秒表清零，run() 函数是用来描述秒针前进一秒的动作，接下来是三个运算符重载函数。
先来看一下 run() 函数的实现，run() 函数一开始让秒针自增，如果此时自增结果等于60了，则应该进位，分钟加1，秒针置零。
operator++() 函数实现自增的前置形式，直接返回 run() 函数运行结果即可。
operator++ (int n) 函数实现自增的后置形式，返回值是对象本身，但是之后再次使用该对象时，对象自增了，所以在该函数的函数体中，先将对象保存，然后调用一次 run() 函数，之后再将先前保存的对象返回。在这个函数中参数n是没有任何意义的，它的存在只是为了区分是前置形式还是后置形式。
自减运算符的重载与上面类似，这里不再赘述。
例题（属于友元函数的 运算符重载函数）
因为+是双目运算符，但是函数里只传了一个参数，就必然使用了this指针，那就肯定不是友元函数了
-
因为友元函数没有当前对象，因此要定义单目运算符，就需要单参函数，要定义双目运算符，就需要双参函数；
-
定义后置“++"或后置“–"运算是特例，它们是单目运算符，但需要两个形参，头一个形参是作用对象，后一个是int形参；
-
用友元函数可以定义成员函数不能实现的运算，例如一些双目运算符，右操作数是本类对象，而左操作数不是本类对象；
-
成员函数体中，当前对象作为一个操作数，无形参形式可以定义单目运算符
作者：Geng1995
链接：https://www.nowcoder.com/exam/test/72063274/submission