重载自加自减运算符

1.自加自减运算符

自增运算符和自减运算符是有前置和后置之分的，如：a++  // 后置自增运算符 ++a  // 前置自增运算符 b--  // 后置自减运算符 --b  // 前置自减运算符
在C++规定： - 前置运算符作为一元运算符重载，重载为成员函数的格式如下：

    T & operator++(); // 前置自增运算符的重载函数，函数参数是空
    T & operator--(); // 前置自减运算符的重载函数，函数参数是空
后置运算符作为二元运算符重载，多写一个没用的参数，重载为成员函数的个数如下：
    T  operator++(int); // 后置自增运算符的重载函数，多一个没用的参数
    T  operator--(int); // 后置自减运算符的重载函数，多一个没用的参数

2.前置和后置运算符的返回值

为什么前置运算符返回的是引用 & ？
为什么后置运算符返回的是普通的对象（临时对象）？
主要是因为为了保持原本 C++ 前置和后置运算符的特性：

• 前置运算符的特性

int a = 0
// (++a) = 5; 可以拆解成:
// a = a + 1; 
// a = 5;
(++a) = 5; // 前置++

a 先自增 +1 后， a 的值就为 1 ，然后再参与 a=5 的运算，所以最后 a 的值是 5。

这说明 (++a) 返回的是自增后 a 变量， a 变量在后续运算过程中，a 变量的值会被修改。所以前置运算符的重载函数的返回值必须是引用 &。

• 后置运算符的特性

而后置运算符，是不能作为左值的，也就是 (a++) = 5; 是不成立的，所以后置运算符的重载函数的返回值就是普通的对象。

3. 运算符重载函数的编写

#include <iostream>
using namespace std;

class Myint {
public:
    Myint(int num) {
        this->num = num;
    }//构造函数用于初始化 Myint 类的对象。它接受一个整数参数 num，并将其赋值给类的成员变量 num。

    
    Myint& operator++() {
        this->num = this->num + 1;//先加，再返回 ++a运算
        return *this;//返回该都对象的引用
    }
    
    Myint operator++(int )//后置++ a++运算
     {
        Myint tmp = *this;//先备份，在返回，再加一，再返回的是一个对象而不是引用
        this->num=this->num + 1;
        return tmp;
    }


    int num;
};
ostream &operator<<(ostream &cout, const Myint &p) {
        cout << p.num;
        return cout;}

void test1() {
    Myint p1(10);
    cout << p1 << endl;
    ++p1;
    cout << ++p1 << endl;
    cout << p1++ << endl;
}

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

解释

1. 构造函数用于初始化 Myint 类的对象。它接受一个整数参数 num，并将其赋值给类的成员变量 num。
2. 前置递增运算符 ++ 的重载函数。它将对象的 num 成员加一，并返回递增后的对象的引用。
3. 后置递增运算符 ++ 的重载函数。它先创建一个临时对象 tmp，将当前对象的值赋给 tmp，然后将当前对象的 num 成员加一。最后，返回临时对象 tmp 的副本。
4. 输出流运算符 << 的重载函数，用于打印 Myint 类的对象。它将对象的 num 成员输出到 cout 流中，并返回 cout 流的引用。
5. main 函数调用 test1 函数，执行测试并返回 0，表示程序成功结束。

 结果：

4.前置和后置运算符的性能比较

从上面的例子，我们看到后置运算符的重载函数的执行步骤：

  1. 先要产生一个临时对象来保存未自增或自减前的对象；

  2. 接着成员变量自增或自减；

  3. 最后返回修改前的对象；

而前置运算符的重载函数的执行步骤：

  1. 成员变量自增或自减；

  2. 返回对象引用；

可见，前置运算符的重载函数是比后置运算符的重载函数性能是更高的，开销相对比较少。

当然对于普通变量类型，如int、double、long等，前置和后置是性能差距是不大的。重要是我们在对于对象和迭代器使用自增或自减时，最好用前置的运算符的方式，这样可以减少开销。