C++学习_运算符重载

r囧r小猫 2022-05-27 09:11 233阅读 0赞

#### 运算符重载 ####

**1.概念：**赋予已经存在的，允许重载的运算符新的含义。

**2.不允许重载的运算符：**  
‘.’ 成员选择符  
‘::’域解析操作符  
‘?:’条件操作符  
‘.\*’成员对象选择符

**3.注意：**

*  不能创建新的符号，只能重载C++中已经存在的，并且允许重载的运算符
 *  用于内置类型变量的操作符，其含义不可以改变，eg:‘+’就不可以改变其含义
 *  ‘==’和‘!=’一般要成对重载
 *  前置自增 / 自减必须返回被增量 / 被减量的引用，后置自增 / 自减必须返回旧值，并且是值返回而不是引用返回，参数用int来占位以区分于前置自增 / 自减
 *  “=、（）、\[\]、->”只能作为成员函数重载
 *  输入操作符>>和输出操作符<<必须定义为类的友元函数

**4.一些建议：**

*  对于单目运算符，建议选择成员函数重载
 *  对于运算符”+= -= /= \*= &= != ~= %= <<= >>= “等，建议重载为成员函数
 *  对于其他运算符，建议重载为友元函数

**5.几个问题：**

> 1）**为什么要以友元函数的形式重载 ‘+’ ?** (第三条其他情况类似)  
> 之所以要讲’+’以友元函数的形式重载，是为了保证‘+’运算符能够被对称的处理；换句话说，数字在 + 左边和右边都是正确的。下面我用代码说明可能会比语言更直观一些：

#include <iostream>
    using namespace std;
    
    //复数类
    class Complex{
    public:
        Complex(): m_real(0.0), m_imag(0.0){ }
        Complex(double real, double imag): m_real(real), m_imag(imag){ }
        Complex(double real): m_real(real), m_imag(0.0){ }  //转换构造函数
    public:
        friend Complex operator+(const Complex &c1, const Complex &c2);
    public:
        double real() const{ return m_real; }
        double imag() const{ return m_imag; }
    private:
        double m_real;  //实部
        double m_imag;  //虚部
    };
    
    //重载+运算符
    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;
    }
    
    int main(){
        Complex c1(10, 20);
        Complex c2 = c1 + 15.6;
        Complex c3 = 12.34 + c1;
        cout<<c2.real()<<" + "<<c2.imag()<<"i"<<endl;
        cout<<c3.real()<<" + "<<c3.imag()<<"i"<<endl;
    
        return 0;
    }

如果将operator+定义为成员函数，那么Complex c2=c1+15.6就会转换成下面这种形式：  
`Complex c2=c1.operator+(Complex(15.6));`  
这是通过对象调用成员函数。而对于Complex c3=12.34+c2; ，编译器就会尝试转换成这种形式：  
`Complex c3=(12.34).operator+(c1)`  
显然这就错了，因为double类型并没有通过成员函数的形式重载+。即以成员函数的形式重载+，只能计算 c1+15.6,而不能计算15.6+c1,而这就不符合我们人类的逻辑了。

> **2）赋值运算符需要注意的几个问题：**  
> ①为什么赋值运算符重载需要有返回值？  
> ②是返回“对象的值”还是返回“对象的引用”？  
> ③返回当前对象（\*this)还是返回参数中的对象？  
> ④如果出现a=a这样的语句有没有应对策略（a是对象）？  
> 这几个问题的答案蕴含在下面的代码中-.-！

class Date
    {
    public:
        Date(int year=0,int month=0,int day=0):
        d_year(year),d_month(month),d_day(day){}
    
        Date& operator=(const Date& pos)//①
        {
            if(&pos != this)//②
            {
                d_year=pos.d_year;
                d_month=pos.d_month;
                d_day=pos.d_day;
                return *this;//③
            }
        }       
    private:
        int d_year;
        int d_month;
        int d_day;
    }
    int main(void)
    {
        Date date1,date2,date3;
        date3=date2=date1;//④
    }

上面的代码中画圈圈的地方就是上面那四个问题的答案，**解析如下：**

①：这一行代码有两个地方需要注意，**第一个**就是我们**第三个问题的答案，返回对象的引用**，原因就是，如果返回的是对象的值，那么在结束这个函数的时候会有一次拷贝构造函数的调用（算是额外的开销吧），原因我在[C++学习\_构造和析构][C]里已经讲清楚了，所以一般情况下，如果没有特殊需求，需要返回对象的，我们都返回对象的引用。而它为什么要有返回值呢？答案是为了实现连续赋值（圈圈④）。**第二个**地方就是它的参数是const修饰的类类型的引用，用引用的目的是和上面相同（避免额外的函数调用开销），加const修饰是因为参数是一个输入形参数，为了避免该对象在函数中被意外修改的缘故。（实际上，这里的门道可不是这一句话就能搞定的，为了不再大幅度扩展本篇博文的长度，请转到：[输入型参数和输出型参数][Link 1]

②：这行代码就处理了上面的第四个问题，直接比较this和参数的地址是否一致即可。  
③：这行代码是第三个问题的答案，返回当前对象，原因是，这样是为了保证连续赋值的规则符合人类的逻辑。我解释一下这句话：就是如果返回的是参数，体现在代码中即`date1`,那么第④行代码的意思就变成了：用date1给date2赋值，再用date1给date3赋值，因为你第二次调用返回的是date1的引用，所以就相当于是用date1给data3赋值。显然这样就不符合人类的思维逻辑了，人类看到这行代码就会想到用date1给date2赋值，再用被赋值后的date2给date3赋值，这样应该讲明白了吧。

**6.几个重要的重载实例：**  
1）前置自增运算符和后置自增运算符的重载（自减同）  
代码：

//前置自增
        Date& operator=()
        {
            d_day++;
            return *this;
        }
        //后置自增
        Date operator=(int)
        {
            Date temp=*this;
            d_day++;
            return temp;
        }

**解析：**自增运算符重载需要注意的有以下几个地方：  
①：为了区分前置自增和后置自增，规定在后置自增的参数列表中加一个`int`类型作为占位符，可以简记为“**后后有参数**”，这个占位符的作用只有一个，就是和前置自增运算符重载函数构成重载，在使用的时候不用给它传递实参。  
②：为了提高效率，我们一般在返回类的对象的时候都返回对象的引用，但是为什么在设计后置自增运算符重载函数的时候却返回对象的值呢？  
原因是，由于函数体设计的特殊原因，我们只能返回一个在栈上创建的对象，可是C++有规定，不能返回栈空间上的引用或指针（详细参见 [C++学习\_引用][C 1] ），所以这里只能返回对象本身了。

2）左移运算符 “<<”的重载  
先来一个有缺陷的实现：

class Date
    {
    public:
        Date(int year=0,int month=0,int day=0):
        d_year(year),d_month(month),d_day(day){}
    
        ostream& operator<<(ostream &_cout)
        {
            _cout<<d_year<<"-"<<d_month<<"-"<<d_day;
            return _cout;
        }
    private:
        int d_year;
        int d_month;
        int d_day;
    }

为什么说这个是有缺陷的实现呢？因为如果把”<<“重载函数作为成员函数来重载，那么这个“<<“就只能像下面这样用：

Date d1;
    d1<<cout;//①
    d1.operator<<(cout);//②

是不是感觉这样很奇怪？②行代码的就是调用运算符重载函数的真正形态，也没有什么说的，（解释一下，以下这个<<重载函数简称为重载函数）我特别解释一下①行代码。因为重载函数被作为类的非static成员函数，所以它的第一个参数就一定是this指针，代表当前对象，而”<<”运算符有两个操作数，左边只能是”\*this”,所以右边就只能是输出流对象，写出来也就是①行代码那个奇怪的样子，显然这并不能让重载这个函数的程序员满意！由此，我们采用运算符重载函数的第二种方式，作为友元函数。

class Date
    {
    public:
        Date(int year=0,int month=0,int day=0):
        d_year(year),d_month(month),d_day(day){}
    
    friend ostream& operator<<(ostream &_cout,const Date& pos); 
    private:
    
        int d_year;
        int d_month;
        int d_day;
    }
    ostream& operator<<(ostream &_cout,const Date& pos)
    {
        _cout<<pos.d_year<<"-"<<pos.d_month<<"-"<<pos.d_day;
        return _cout;
    }

现在重载函数的第一个参数，就是输出流对象，第二个参数就是需要输出的对象，现在的输出方式就正常了：

Date d1;
    cout<<d1<<endl;

关于“<<”运算符重载还需要注意几个问题：

*  “<<”运算符重载函数要有返回值，原因是为了实现连续赋值
 *  一般不在“<<”运算符重载函数函数体内做格式控制，比如：`_cout<<d_year<<"-"<<d_month<<"-"<<d_day<<endl;` 最后的换行控制符就是一个换行控制，如果在外部使用这个运算符的时候不知道内部的操作，比方：`cout<<d1<<endl;`,这就会出现意料之外的事，因为函数体内部还有一个换行符。
 *  “<<”运算符重载函数的第二个参数要加const限定表明这是一个输入型参数，引用类型是为了提高效率

[C]: https://blog.csdn.net/zanda_/article/details/79915237
[Link 1]: https://blog.csdn.net/dhauwd/article/details/77916731
[C 1]: https://blog.csdn.net/zanda_/article/details/79889068%20C++_%E5%BC%95%E7%94%A8