跳到主要内容

C++ 自增自减运算符重载

自增（++）和自减（--）运算符是C++中常用的一元运算符，它们各有前置和后置两种形式。当应用于自定义类型时，我们需要通过运算符重载来实现这些操作。本文将详细介绍如何正确地重载这两种运算符，并解释它们前置和后置形式的区别。

自增自减运算符基本概念​

在学习重载之前，让我们先回顾一下自增和自减运算符的基本用法：

  • 前置形式：++i 或 --i，先增加/减少值，再使用结果
  • 后置形式：i++ 或 i--，先使用原值，再增加/减少

这两种形式在内置类型（如整数）上的行为是由C++语言定义的。当我们重载这些运算符时，需要模拟这种行为。

重载自增自减运算符的语法​

前置运算符重载​

前置形式被视为普通的一元运算符，重载方式如下：

cpp
ReturnType operator++();    // 前置++
ReturnType operator--();    // 前置--

后置运算符重载​

后置形式需要一个额外的整型参数（仅作为区分标记使用）：

cpp
ReturnType operator++(int); // 后置++
ReturnType operator--(int); // 后置--
备注

整型参数 int 只是一个占位符，用于区分前置和后置形式，在函数实现中通常不使用这个参数。

实现前置和后置运算符​

让我们通过一个简单的计数器类来演示如何实现这些运算符：

cpp
#include <iostream>

class Counter {
private:
    int count;

public:
    // 构造函数
    Counter(int c = 0) : count(c) {}

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

    // 前置++
    Counter& operator++() {
        ++count;         // 先增加
        return *this;    // 再返回自身引用
    }

    // 后置++
    Counter operator++(int) {
        Counter temp = *this; // 保存当前状态
        ++count;              // 增加成员变量
        return temp;          // 返回原来的状态（副本）
    }

    // 前置--
    Counter& operator--() {
        --count;         // 先减少
        return *this;    // 再返回自身引用
    }

    // 后置--
    Counter operator--(int) {
        Counter temp = *this; // 保存当前状态
        --count;              // 减少成员变量
        return temp;          // 返回原来的状态（副本）
    }
};

int main() {
    Counter c(5);
    
    // 测试前置++
    Counter d = ++c;
    std::cout << "前置++后: c = " << c.getValue() << ", d = " << d.getValue() << std::endl;
    
    // 测试后置++
    Counter e = c++;
    std::cout << "后置++后: c = " << c.getValue() << ", e = " << e.getValue() << std::endl;
    
    // 测试前置--
    Counter f = --c;
    std::cout << "前置--后: c = " << c.getValue() << ", f = " << f.getValue() << std::endl;
    
    // 测试后置--
    Counter g = c--;
    std::cout << "后置--后: c = " << c.getValue() << ", g = " << g.getValue() << std::endl;
    
    return 0;
}

输出结果：

前置++后: c = 6, d = 6
后置++后: c = 7, e = 6
前置--后: c = 6, f = 6
后置--后: c = 5, g = 6

前置与后置实现的关键区别​

  1. 返回类型不同：

    • 前置运算符返回引用（Counter&）
    • 后置运算符返回对象副本（Counter）

  2. 实现方式不同：

    • 前置形式直接修改对象并返回修改后的引用
    • 后置形式需要创建临时对象保存原始状态，然后修改当前对象，最后返回临时对象

  3. 效率考量：

    • 前置形式通常更高效，因为不需要创建临时对象
    • 后置形式需要额外构造和销毁临时对象
性能提示

当可以选择使用前置或后置形式时，优先选择前置形式（如++i而非i++），尤其是对于复杂对象，可以获得更好的性能。

实际应用场景​

1. 迭代器实现​

自定义迭代器是重载自增自减运算符最常见的应用场景之一：

cpp
template <typename T>
class MyIterator {
private:
    T* ptr;
    
public:
    MyIterator(T* p = nullptr) : ptr(p) {}
    
    // 前置++
    MyIterator& operator++() {
        ptr++;
        return *this;
    }
    
    // 后置++
    MyIterator operator++(int) {
        MyIterator temp = *this;
        ptr++;
        return temp;
    }
    
    // 解引用运算符
    T& operator*() const {
        return *ptr;
    }
    
    // 其他必要的运算符...
};

2. 智能指针​

在实现自定义智能指针时，重载自增自减运算符可以让指针具有像普通指针一样的行为：

cpp
template <typename T>
class SmartPtr {
private:
    T* ptr;
    
public:
    // 构造和析构函数略...
    
    // 前置++：移动到下一个元素
    SmartPtr& operator++() {
        ptr++;
        return *this;
    }
    
    // 后置++
    SmartPtr operator++(int) {
        SmartPtr temp = *this;
        ptr++;
        return temp;
    }
};

3. 分数类​

重载自增自减运算符可以使分数类支持加一或减一操作：

cpp
class Fraction {
private:
    int numerator;
    int denominator;
    
public:
    Fraction(int n = 0, int d = 1) : numerator(n), denominator(d) {}
    
    // 前置++：分数值加1
    Fraction& operator++() {
        numerator += denominator;  // 增加一个单位
        return *this;
    }
    
    // 后置++
    Fraction operator++(int) {
        Fraction temp = *this;
        numerator += denominator;
        return temp;
    }
    
    // 显示分数
    void display() const {
        std::cout << numerator << "/" << denominator;
    }
};

注意事项和最佳实践​

  1. 符合直觉：让重载的运算符行为与内置类型的行为保持一致，不要创造出让人困惑的行为。

  2. 返回类型：

    • 前置形式通常返回引用（效率更高）
    • 后置形式必须返回值（符合语义）

  3. 常见错误：

    cpp
    // 错误：前置运算符不应返回值而应返回引用
    Counter operator++() {
        count++;
        return *this;  // 不是引用，效率低
    }

    // 错误：后置运算符返回引用
    Counter& operator++(int) {
        Counter temp = *this;
        count++;
        return *this;  // 违反了后置运算符的预期行为
    }

  4. 成员函数 vs 友元函数：自增自减运算符通常实现为成员函数，因为它们直接修改对象状态。

警告

后置运算符返回临时对象可能导致较低的性能，特别是对于复杂类。除非确实需要后置形式的语义，否则应优先使用前置形式。

总结​

重载C++的自增自减运算符需要同时考虑前置和后置两种形式。关键点包括：

  1. 前置形式不需要参数，通常返回引用
  2. 后置形式需要一个int类型的参数作为区分标记，返回对象副本
  3. 前置形式通常比后置形式效率更高
  4. 实现时要保持与内置类型一致的语义

通过正确重载这些运算符，我们可以让自定义类型支持像内置类型一样的递增和递减操作，提高代码的可读性和直观性。

练习​

  1. 创建一个表示角度的Angle类，角度值在0到359度之间。实现自增和自减运算符，使得当角度超过359度时回到0度，当角度小于0度时回到359度。

  2. 为一个简单的Date类实现自增和自减运算符，使其可以递增到下一天或递减到前一天，并正确处理月末和年末的情况。

  3. 实现一个简单的循环缓冲区类，重载自增和自减运算符来移动缓冲区的读写指针。

进一步阅读​

  • C++标准库中的迭代器实现
  • 智能指针设计中的运算符重载
  • C++运算符重载的最佳实践和设计模式