资讯

历史

科技

环境与自然

成长

游戏

财经

文学与艺术

美食

健康

家居

文化

情感

汽车

三农

军事

旅行

运动

教育

生活

星座命理

C++语法——详解运算符重载

创作时间:

作者:

@小白创作中心

C++语法——详解运算符重载

引用

CSDN

https://blog.csdn.net/weixin_61857742/article/details/126010673

运算符重载是C++的一个重要特性，它允许我们为已有的运算符赋予新的含义，从而实现更灵活和直观的代码编写方式。本文将详细介绍运算符重载的基本概念、实现方法以及应用场景，帮助读者全面掌握这一强大的编程工具。

一. 运算符重载介绍

运算符重载，就是让原本已经存在的运算符有了新的用法和意义。比如我们熟知的减号（-），原本是用来进行数字的相减处理。但经过运算符重载后，它可以用来进行其他类型的相减，像时间相减、日期相减、字符相减等等。只要是你能想到的，通过运算符重载基本都能够实现。

对于C++而言，运算符重载一般是作为类的成员函数出现。因为当我们需要运算符重载时，往往是类中一种特殊的类型需要处理或者类本身需要处理。就像我们可能会把时间作为一个类，里面有小时、分钟、秒。如果让时间相减，那么减号的参数类型就变成了时间类。因此，重载最好作为类的成员函数出现，减少在我们调用运算符重载时发生冲突的可能。

二. 运算符重载形式

[返回值] operator[运算符] (参数...) { ... }；

（一）. 参数

这里我们必须注意的是，重载的参数个数必须与运算符原意的个数一致。比如+号的参数就是左加数和右加数两个。那么当我们重载加号时也要保证有左右两个加数作为参数。

重载作为普通函数时：

单目：右操作数是形参；
双目：左边形参作为运算符左操作数，右边形参是右操作数。

重载作为类的成员函数时：

如果运算符参数只有一个，那么不需要写参数；
如果运算符参数有两个，那么只需要写一个参数。

因为类的成员函数默认有一个this指针。它会直接指向类本身。换句话说，当我们写出运算符重载时，有一个参数就已经被this指针包含了。

单目运算符，this所指向运算符右参数，因为单目运算符的参数一般都在右边。
双目运算符，this指向运算符左参数。

以减号为例，两个时间类a和b相减时。如果是a - b,那么this指针指向a，反之则指向b。在声明函数时，我们只需要写右参数即可。a - b的话只需要写 int operator-(Time b);

当然，单目运算符由于只有一个参数，且该参数被this所指向，那么我们无需声明任何参数即可。

（二）. 返回值

运算符的返回值类型取决于该重载函数的作用是什么。

比如a + b的作用是得到一个加数，那么返回值就是a+b的值。a += b的作用是让a的值改变，既然是让参数a的值改变，那么就无需返回值。

还有就是如果我们需要运算符支持多次操作那么也需要返回值。比如流插入运算符<<。我们可能需要多次进行插入，像cout << a << b << c;之类就需要返回流ostream本身以便于之后的流插入工作。

（三）. 应用

下面，我来为大家展示几种运算符重载方式：

加号（双目）：

class Time
{
    int _hour;
    int _min;
    int _sec;
public:
    Time(int hour = 0, int min = 0, int sec = 0)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
    }
    void Print()
    {
        cout << _hour << ":" << _min << ":" << _sec << endl;
        
    }
    Time operator+(int min)//加分钟
    {
         Time t(*this);//因为是+号，规定不能改变左右参数的值，所以使用t来取和用以返回。
         t._min += min;
         if (t._min > 59)//检查时间正确性
         {
             t._hour += (t._min / 60);
             if (t._hour > 23)
                 t._hour %= 24;
             t._min %= 60;
         }
         return t;
    }
};
int main()
{
    Time a(10, 30, 30);
    (a + 140).Print();
    return 0;
}

自增（单目）：

class Time
{
    int _hour;
    int _min;
    int _sec;
public:
    Time(int hour = 0, int min = 0, int sec = 0)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
    }
    void Print()
    {
        cout << _hour << ":" << _min << ":" << _sec << endl;
        
    }
    int& operator++()// ++a和a++分别如何我们之后会讲到，这里使用++a
    {
        return _hour += 1;//为方便演示，让小时+1，但不再判断时间正确性
    }
};
int main()
{
    Time a(10, 30, 30);
    ++a;
    a.Print();
    return 0;
}

三. 特殊的运算符重载

（一）. 默认赋值运算符重载

即便我们没有手动定义赋值运算符重载，C++也为我们提供了默认函数。

在默认赋值重载中，内置类型按字节拷贝，自定义类型会去调自己的默认赋值重载。这点与默认拷贝构造极为相似，不懂的可以看看这篇文章：详解析构函数、拷贝构造函数

因此，当我们的类中只有int、char、double之类内置类型时，无需再写赋值重载。

但是，如果有指针、malloc、new之类指向地址、手动开辟空间的，一般情况下还是需要手写重载的。

总而言之，默认赋值重载只能进行浅拷贝，是否需要手动去写要根据类的成员类型判断。

class Time
{
    int _hour;
    int _min;
    int _sec;
public:
    Time(int hour = 0, int min = 0, int sec = 0)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
    }
    void Print()
    {
        cout << _hour << ":" << _min << ":" << _sec << endl;
        
    }
    
};
int main()
{
    Time a;
    Time b(20, 10, 50);
    a.Print();
    a = b;//调用默认赋值重载
    a.Print();
    return 0;
}

值得注意的一点是：

我们需要分清楚赋值重载与拷贝构造的区别。

拷贝构造只能发生在对象被定义时，而赋值则是在对象已经被定义完毕后。

void main()
{
    Time A;
    Time T = A;//拷贝构造
    Time B;
    B = A;//赋值重载
}

（二）. 自增运算符A++与++A

因为单目运算符重载的this指针指向右边，所以按正常写法我们写出来的是++A。

C++规定，A++的写法是在正常++运算重载基础上，在参数上写一个int类型的参数。

方式如下：

class Time
{
    int _hour;
    int _min;
    int _sec;
public:
    Time(int hour = 0, int min = 0, int sec = 0)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
    }
    void Print()
    {
        cout << _hour << ":" << _min << ":" << _sec << endl;

    }
    //为方便演示，让小时+1，但不再判断时间正确性
    Time& operator++()// ++A
    {
        _hour += 1;
        return (*this);//因为自增直接返回this用引用接收
    }
    Time operator++(int)//A++，参数写int或int i都可以
    {
        Time ret(*this);
        _hour += 1;
        return ret;//需要返回this自增之前的结果，所以用临时变量返回
    }
};
int main()
{
    Time a(10, 30, 30);
    //(++a).Print();
    //a.Print();
    (a++).Print();
    a.Print();
    return 0;
}

（三）. 流提取>>与流插入<<

对于流而言，因为是双目运算符，this指针本应该指向左边的类，但左操作数是一个流，又与this的类型冲突。那么就会出现很奇怪的现象：

因为this指针会默认指向类，而我们需要让左参数指向流，右参数指向类。所以重载就不能作为类的成员函数出现了。

这时，就需要用到友元函数friend。友元函数本身是一个普通函数，但是作为类的友元，能够调用类内的成员，包括private。而且参数不用被类限制为第一个必须是this所指的对象本身。

使用时，我们只需要在类内声明有个友元函数即可。

#include"head.h"
class Time
{
    friend ostream& operator<<(ostream& out, Time& t);//友元函数，声明
    friend istream& operator>>(istream& in, Time& t);
    int _hour;
    int _min;
    int _sec;
public:
    Time(int hour = 0, int min = 0, int sec = 0)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
    }
    
};
ostream& operator<<(ostream& out, Time& t)//流插入
{
    out << t._hour << ":" << t._min << ":" << t._sec << endl;
    return out;
}
istream& operator>>(istream& in, Time& t)//流提取
{
    in >> t._hour >> t._min >> t._sec;
    return in;
}
int main()
{
    Time a;
    cin >> a;
    cout << a;
    return 0;
}