C++:自增运算符（++）重载

自增运算符（++）分为前置自增和后置自增，它们两者主要的区别是：返回的值不同，以及执行自增操作的顺序不同。

1. 前置自增运算符 ++：

   • 前置自增运算符首先将操作数加1，然后返回自增后的值。

   • 这意味着如果你使用前置自增运算符对一个变量进行操作，你会在其他任何操作之前得到自增后的值。

2. 后置自增运算符 ++：

   • 后置自增运算符也会将操作数加1，但是它会返回自增前的值。

   • 这意味着如果你使用后置自增运算符对一个变量进行操作，你会在其他任何操作之后得到自增前的值。

自减运算符（--）重载的实现思路也是一样的。

如下代码：

#include <iostream>
​
int main() {
    int a = 5;
    int b = 5;
​
    std::cout << "Original values: a = " << a << ", b = " << b << std::endl;
​
    int result1 = ++a; // 前置自增
    int result2 = b++; // 后置自增
​
    std::cout << "After pre-increment: a = " << a << ", result1 = " << result1 << std::endl;
    std::cout << "After post-increment: b = " << b << ", result2 = " << result2 << std::endl;
​
    return 0;
}
​

最后得到的结果：

Original values: a = 5, b = 5
After pre-increment: a = 6, result1 = 6
After post-increment: b = 6, result2 = 5

在前置自增的情况下，变量 a 在自增之后变为6，并且 result1 也是6；而在后置自增的情况下，变量 b 在自增之前为5，自增之后变为6，但是 result2 返回的是自增之前的值，因此是5。

在了解前置自增和后置自增的区别后那么这个时候我们就可以对这两种自增运算符进行重载：

前置++

class MyString {
public:
    int m_nNumberA;
    int m_nNumberB;
public:
    MyString() {};
    MyString(int NumberA, int NumberB) :m_nNumberA(NumberA), m_nNumberB(NumberB) {};
    MyString operator++(){
        this->m_nNumberA++;
        this->m_nNumberB++;
        return *this;
    };
};

在这个 MyString 类中，重载了前置自增运算符 ++。

1. MyString operator++()：这是重载前置自增运算符 ++ 的函数声明。这个函数没有参数，因为前置自增运算符不需要参数。

2. this->m_nNumberA++; 和 this->m_nNumberB++;：在函数体内，成员变量 m_nNumberA 和 m_nNumberB 分别被递增了1。使用 this 指针是为了明确指出正在操作当前对象的成员变量。

3. return *this;：返回自增后的对象本身。这样可以实现链式调用，允许连续对同一个对象执行多次自增操作。

在函数中进行使用

int main() {
    MyString StringC(40,80);
    
    ++StringC;
​
    std::cout << "自增后" << StringC.m_nNumberA << std::endl;
    std::cout << "自增后" << StringC.m_nNumberB << std::endl;
​
    system("pause");
    return 0;
}

运行后的结果：

后置++

class MyString {
public:
    int m_nNumberA;
    int m_nNumberB;
public:
    MyString() {};
    MyString(int NumberA, int NumberB) :m_nNumberA(NumberA), m_nNumberB(NumberB) {};
    
    //后置运算符重载
    MyString operator++(int){
        MyString * tempObj = this;
        this->m_nNumberA++;
        this->m_nNumberB++;
        return *tempObj;
    }

1. MyString operator++(int)：这是重载后置自增运算符 ++ 的函数声明。参数列表中的 int 参数并没有用到，它只是用来区分前置和后置自增运算符重载函数。

2. MyString * tempObj = this;：创建了一个指向当前对象的指针 tempObj，这是为了保存当前对象的副本，在自增操作之前返回。

3. this->m_nNumberA++; 和 this->m_nNumberB++;：在函数体内，成员变量 m_nNumberA 和 m_nNumberB 分别被递增了1。使用 this 指针是为了明确指出正在操作当前对象的成员变量。

4. return *tempObj;：返回自增前的对象的副本。这是后置自增运算符的特性，它应该返回自增前的值。

在主函数中进行使用：

int main() {
    MyString StringD;
    StringD = StringObjA++;
​
    std::cout << "StringD:" << StringD.m_nNumberA << std::endl;
    std::cout << "StringD:" << StringD.m_nNumberB << std::endl;
​
    std::cout << "StringObjA:" << StringObjA.m_nNumberA << std::endl;
    std::cout << "StringObjA:" << StringObjA.m_nNumberB << std::endl;
​
    system("pause");
    return 0;
}

最后结果为：

因为使用的是后置++,所以StringD的赋值会在StringObjA自增之前进行。

至此自增运算符重载完成。