第二节 · 换一种走路的方式 · 递增递减运算符定义

下标运算符 [] 和函数调用运算符 () 是两个特殊的运算符，它们让对象可以像数组或函数一样使用。

---

下标运算符 []

class Array
{
private:
    int data[100];
    
public:
    // 返回引用，允许读写
    int& operator[](int index)
    {
        return data[index];
    }
    
    // const 版本，只读
    const int& operator[](int index) const
    {
        return data[index];
    }
};

int main()
{
    Array arr;
    arr[0] = 42;           // 调用非 const 版本
    cout << arr[0] << endl;
    
    const Array& ref = arr;
    cout << ref[0] << endl;  // 调用 const 版本
    // ref[0] = 1;  // 错误：const 不能修改
    
    return 0;
}

---

带边界检查的下标

class SafeArray
{
private:
    int* data;
    size_t size;
    
public:
    SafeArray(size_t n) : data(new int[n]()), size(n) {}
    ~SafeArray() { delete[] data; }
    
    int& operator[](size_t index)
    {
        if (index >= size)
        {
            throw out_of_range("Index out of bounds");
        }
        return data[index];
    }
    
    const int& operator[](size_t index) const
    {
        if (index >= size)
        {
            throw out_of_range("Index out of bounds");
        }
        return data[index];
    }
};

int main()
{
    SafeArray arr(10);
    
    try
    {
        arr[100] = 1;  // 抛出异常
    }
    catch (const out_of_range& e)
    {
        cout << "Error: " << e.what() << endl;
    }
    
    return 0;
}

---

多维下标

class Matrix
{
private:
    int rows, cols;
    vector<int> data;
    
public:
    Matrix(int r, int c) : rows(r), cols(c), data(r * c) {}
    
    // 代理类实现二维下标
    class Row
    {
    private:
        int* rowData;
    public:
        Row(int* data) : rowData(data) {}
        int& operator[](int col) { return rowData[col]; }
    };
    
    Row operator[](int row)
    {
        return Row(&data[row * cols]);
    }
    
    // 或者用 () 运算符更简单
    int& operator()(int row, int col)
    {
        return data[row * cols + col];
    }
};

int main()
{
    Matrix m(3, 4);
    
    m[0][0] = 1;    // 用 [][]
    m(1, 2) = 42;   // 用 ()
    
    cout << m[0][0] << endl;
    cout << m(1, 2) << endl;
    
    return 0;
}

---

函数调用运算符 ()

重载 () 的对象称为函数对象或仿函数（functor）。

class Adder
{
private:
    int value;
    
public:
    Adder(int v) : value(v) {}
    
    int operator()(int x) const
    {
        return x + value;
    }
};

int main()
{
    Adder add10(10);
    
    cout << add10(5) << endl;   // 15
    cout << add10(20) << endl;  // 30
    
    return 0;
}

---

函数对象与 STL

#include <algorithm>
#include <vector>

// 自定义比较器
class DescendingCompare
{
public:
    bool operator()(int a, int b) const
    {
        return a > b;  // 降序
    }
};

// 自定义谓词
class IsEven
{
public:
    bool operator()(int x) const
    {
        return x % 2 == 0;
    }
};

int main()
{
    vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    
    // 使用函数对象排序
    sort(v.begin(), v.end(), DescendingCompare());
    // v: 9, 6, 5, 4, 3, 2, 1, 1
    
    // 统计偶数个数
    int count = count_if(v.begin(), v.end(), IsEven());
    cout << "Even count: " << count << endl;  // 3
    
    return 0;
}

---

带状态的函数对象

class Counter
{
private:
    int count = 0;
    
public:
    void operator()(int x)
    {
        ++count;
        cout << "Processing " << x << endl;
    }
    
    int getCount() const { return count; }
};

int main()
{
    vector<int> v = {1, 2, 3, 4, 5};
    
    Counter c;
    for_each(v.begin(), v.end(), ref(c));  // 用 ref 传引用
    
    cout << "Total: " << c.getCount() << endl;  // 5
    
    return 0;
}

---

函数对象 vs lambda

// 函数对象
class Multiply
{
    int factor;
public:
    Multiply(int f) : factor(f) {}
    int operator()(int x) const { return x * factor; }
};

// 等价的 lambda
auto multiply = [factor = 2](int x) { return x * factor; };

int main()
{
    Multiply m(2);
    cout << m(5) << endl;        // 10
    cout << multiply(5) << endl;  // 10
    
    return 0;
}

---

标准函数对象

#include <functional>

int main()
{
    // 标准库提供的函数对象
    plus<int> add;
    minus<int> sub;
    multiplies<int> mul;
    greater<int> gt;
    
    cout << add(3, 4) << endl;  // 7
    cout << sub(10, 3) << endl; // 7
    cout << mul(4, 5) << endl;  // 20
    cout << gt(5, 3) << endl;   // 1
    
    vector<int> v = {3, 1, 4, 1, 5};
    sort(v.begin(), v.end(), greater<int>());  // 降序
    
    return 0;
}

---

用 [] 实现映射查找

class Config
{
private:
    map<string, string> settings;
    
public:
    string& operator[](const string& key)
    {
        return settings[key];
    }
    
    const string& operator[](const string& key) const
    {
        static string empty;
        auto it = settings.find(key);
        return it != settings.end() ? it->second : empty;
    }
};

int main()
{
    Config config;
    config["name"] = "MyApp";
    config["version"] = "1.0";
    
    cout << config["name"] << endl;  // MyApp
    
    return 0;
}

---

习题

• 实现一个 String 类，支持 [] 访问字符。

• 创建一个多项式类，用 () 计算给定 x 的值。

• 比较函数对象和 lambda 的优缺点。