第四节 · 换一种干活的方式 · 函数调用运算符定义

递增递减运算符（++、--）和成员访问运算符（->、*）的重载有一些特殊的规则和技巧。

---

前置递增递减

class Counter
{
private:
    int value;
    
public:
    Counter(int v = 0) : value(v) {}
    
    // 前置 ++：返回引用
    Counter& operator++()
    {
        ++value;
        return *this;
    }
    
    // 前置 --
    Counter& operator--()
    {
        --value;
        return *this;
    }
    
    int getValue() const { return value; }
};

int main()
{
    Counter c(5);
    
    cout << (++c).getValue() << endl;  // 6
    cout << (++c).getValue() << endl;  // 7
    
    return 0;
}

---

后置递增递减

class Counter
{
private:
    int value;
    
public:
    Counter(int v = 0) : value(v) {}
    
    // 前置
    Counter& operator++()
    {
        ++value;
        return *this;
    }
    
    // 后置：用 int 参数区分，返回旧值
    Counter operator++(int)  // int 是哑参数
    {
        Counter old = *this;  // 保存旧值
        ++value;
        return old;           // 返回旧值
    }
    
    int getValue() const { return value; }
};

int main()
{
    Counter c(5);
    
    cout << (c++).getValue() << endl;  // 5 (返回旧值)
    cout << c.getValue() << endl;       // 6 (但 c 已增加)
    
    return 0;
}

---

迭代器风格

template<typename T>
class ListIterator
{
private:
    Node<T>* current;
    
public:
    ListIterator(Node<T>* node) : current(node) {}
    
    // 解引用
    T& operator*() { return current->data; }
    const T& operator*() const { return current->data; }
    
    // 前置 ++
    ListIterator& operator++()
    {
        current = current->next;
        return *this;
    }
    
    // 后置 ++
    ListIterator operator++(int)
    {
        ListIterator temp = *this;
        current = current->next;
        return temp;
    }
    
    // 比较
    bool operator==(const ListIterator& other) const
    {
        return current == other.current;
    }
    
    bool operator!=(const ListIterator& other) const
    {
        return !(*this == other);
    }
};

---

箭头运算符 ->

template<typename T>
class SmartPtr
{
private:
    T* ptr;
    
public:
    SmartPtr(T* p = nullptr) : ptr(p) {}
    ~SmartPtr() { delete ptr; }
    
    // 解引用
    T& operator*() { return *ptr; }
    const T& operator*() const { return *ptr; }
    
    // 箭头运算符
    T* operator->() { return ptr; }
    const T* operator->() const { return ptr; }
};

struct Point
{
    int x, y;
    void print() { cout << x << ", " << y << endl; }
};

int main()
{
    SmartPtr<Point> sp(new Point{3, 4});
    
    sp->x = 10;       // 等价于 (sp.operator->())->x = 10
    sp->print();      // 10, 4
    
    (*sp).y = 20;     // 用 * 也可以
    
    return 0;
}

---

链式箭头运算符

// 代理类
template<typename T>
class Proxy
{
    T* ptr;
public:
    Proxy(T* p) : ptr(p) {}
    T* operator->() { return ptr; }
};

// 包装类
template<typename T>
class Wrapper
{
    T obj;
public:
    Wrapper(const T& o) : obj(o) {}
    Proxy<T> operator->() { return Proxy<T>(&obj); }
};

struct Data { int value; };

int main()
{
    Wrapper<Data> w(Data{42});
    
    // w.operator->() 返回 Proxy
    // Proxy.operator->() 返回 Data*
    cout << w->value << endl;  // 42
    
    return 0;
}

---

指针风格的类

template<typename T>
class Optional
{
private:
    T* value = nullptr;
    
public:
    Optional() = default;
    Optional(const T& v) : value(new T(v)) {}
    ~Optional() { delete value; }
    
    // 检查是否有值
    explicit operator bool() const { return value != nullptr; }
    
    // 解引用
    T& operator*()
    {
        if (!value) throw runtime_error("No value");
        return *value;
    }
    
    // 箭头
    T* operator->()
    {
        if (!value) throw runtime_error("No value");
        return value;
    }
};

int main()
{
    Optional<string> opt1;
    Optional<string> opt2("hello");
    
    if (opt1) cout << *opt1 << endl;  // 不执行
    if (opt2) cout << opt2->size() << endl;  // 5
    
    return 0;
}

---

为什么前置比后置高效

class BigObject
{
    // 大量数据...
public:
    // 前置：修改后返回引用，不复制
    BigObject& operator++()
    {
        // 修改
        return *this;
    }
    
    // 后置：必须复制旧值
    BigObject operator++(int)
    {
        BigObject old = *this;  // 复制！
        ++(*this);
        return old;             // 再复制！
    }
};

// 所以循环中优先用前置
for (auto it = v.begin(); it != v.end(); ++it)  // 好
for (auto it = v.begin(); it != v.end(); it++)  // 可能有额外开销

---

实现范围迭代

class Range
{
    int start, stop;
    
public:
    Range(int s, int e) : start(s), stop(e) {}
    
    class Iterator
    {
        int current;
    public:
        Iterator(int v) : current(v) {}
        
        int operator*() const { return current; }
        Iterator& operator++() { ++current; return *this; }
        bool operator!=(const Iterator& other) const
        {
            return current != other.current;
        }
    };
    
    Iterator begin() const { return Iterator(start); }
    Iterator end() const { return Iterator(stop); }
};

int main()
{
    // 像 Python 的 range
    for (int i : Range(1, 5))
    {
        cout << i << " ";  // 1 2 3 4
    }
    cout << endl;
    
    return 0;
}

---

习题

• 解释前置和后置递增的参数列表区别。

• 为双向迭代器添加 -- 运算符。

• 实现一个 StepRange 类，支持指定步长。