C++中操作符++重载

原创已于 2024-09-26 16:19:09 修改 · 1.4k 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

于 2024-09-26 15:38:28 首次发布

C/C++ 专栏收录该内容

11 篇文章

订阅专栏

在 C++ 中，运算符 ++ 可以被重载，以自定义类的递增行为。运算符 ++ 分为前置递增（++x）和后置递增（x++），这两种形式的递增操作在语义上有所不同，因此在 C++ 中重载这两个运算符时需要分别实现。

1. 前置递增和后置递增的区别

前置递增（++x）：先递增变量的值，然后返回递增后的值。
后置递增（x++）：先返回变量当前的值，然后再递增变量的值。

2. 重载 `++` 运算符的规则

前置递增：重载为成员函数 operator++()，无参数，返回递增后的对象。
后置递增：重载为成员函数 operator++(int)，接受一个 int 类型的虚拟参数，用以区分前置递增，返回递增前的对象副本。

3. 前置递增运算符的重载

3.1 前置递增（`++x`）的语法

前置递增会先对对象进行自增，然后返回递增后的对象的引用。因此，我们可以将其定义为如下形式：

Counter& operator++() {
    ++value;
    return *this;
}

3.2 前置递增的详细解释

返回类型：返回当前对象的引用（Counter&），因为递增之后的对象仍然是当前对象，所以我们希望返回当前对象的引用以便支持链式调用。
函数体：先对成员变量 value 进行自增操作，然后返回当前对象（*this）。

前置递增的调用示例：

Counter c(5);
++c; // c.value 从 5 递增为 6

4. 后置递增运算符的重载

4.1 后置递增（`x++`）的语法

后置递增需要在递增前先返回对象的值，并且递增后返回的值应该是递增之前的。因此，我们需要将后置递增定义为如下形式：

Counter operator++(int) {
    Counter temp = *this;  // 创建当前对象的副本
    ++value;               // 对当前对象进行递增
    return temp;           // 返回递增前的副本
}

4.2 后置递增的详细解释

返回类型：返回的是当前对象递增前的副本，因此返回类型是 Counter，而不是引用。
函数体：首先保存当前对象的副本（temp），然后对对象的成员变量 value 进行递增，最后返回递增前的副本 temp。
int 参数：虚拟的 int 参数用来区分后置递增和前置递增。这个参数不需要实际使用，只是用于标识后置递增。

后置递增的调用示例：

Counter c(5);
c++; // 先返回 5，然后 c.value 递增为 6

5. 完整的代码示例

以下是包含前置和后置递增重载的完整代码：

#include <iostream>

class Counter {
private:
    int value;
public:
    // 构造函数
    Counter(int v = 0) : value(v) {}

    // 前置递增
    Counter& operator++() {
        ++value; // 递增
        return *this; // 返回自身的引用
    }

    // 后置递增
    Counter operator++(int) {
        Counter temp = *this; // 保存当前对象的副本
        ++value; // 递增
        return temp; // 返回递增前的副本
    }

    // 获取当前值
    int getValue() const {
        return value;
    }
};

int main() {
    Counter c(10);

    // 前置递增
    ++c; // c.value 从 10 递增到 11
    std::cout << "After ++c: " << c.getValue() << std::endl; // 输出 11

    // 后置递增
    c++; // 返回递增前的值 11，c.value 递增到 12
    std::cout << "After c++: " << c.getValue() << std::endl; // 输出 12

    return 0;
}

输出：