C++中是否可重载[]运算符实现不同功能？如何区分读写操作重载数组访问的[]运算符？

当然可以实现区分读写的[]运算符重载，但直接像你那样写两个签名完全一致的operator[]是行不通的——C++的函数重载要求参数列表（类型、数量）必须有差异，这两个函数的参数都是int index，编译器根本分不清谁是谁，会直接报错。

不过我们有个巧妙的解决方案：借助代理类来区分读和写操作。思路是让operator[]返回一个代理对象，而不是直接返回类的引用，然后通过代理类的不同运算符来分别处理读、写逻辑。

完整示例代码 #

#include <iostream>
#include <stdexcept>

class myclass {
private:
    int arr[10]; // 用数组示例更贴合"数组访问"的场景
public:
    // 构造函数：初始化数组为0
    myclass() {
        for (int i = 0; i < 10; ++i) {
            arr[i] = 0;
        }
    }

    // 代理类：负责区分读、写操作
    class Proxy {
    private:
        myclass& parent; // 引用所属的myclass对象
        int index;       // 数组索引
    public:
        // 构造函数：绑定父对象和索引
        Proxy(myclass& p, int idx) : parent(p), index(idx) {}

        // 写操作：重载赋值运算符，处理myclass[n] = B的场景
        Proxy& operator=(const int& value) {
            // 这里可以添加写操作的自定义逻辑，比如日志、校验
            std::cout << "[写操作] 给arr[" << index << "]赋值：" << value << std::endl;
            parent.arr[index] = value;
            return *this;
        }

        // 读操作：重载转换运算符，处理A = myclass[n]的场景
        operator int() const {
            // 这里可以添加读操作的自定义逻辑，比如统计访问次数
            std::cout << "[读操作] 获取arr[" << index << "]的值：" << parent.arr[index] << std::endl;
            return parent.arr[index];
        }
    };

    // 重载[]运算符，返回代理对象
    Proxy operator[](int index) {
        // 先做索引合法性校验
        if (index < 0 || index >= 10) {
            throw std::out_of_range("数组索引越界！");
        }
        return Proxy(*this, index);
    }

    // 可选：支持const对象的读操作
    const int& operator[](int index) const {
        if (index < 0 || index >= 10) {
            throw std::out_of_range("数组索引越界！");
        }
        std::cout << "[const读操作] 获取arr[" << index << "]的值：" << arr[index] << std::endl;
        return arr[index];
    }
};

// 使用示例
int main() {
    myclass obj;

    // 写操作
    obj[3] = 42;

    // 读操作
    int a = obj[3];

    // const对象的读操作
    const myclass const_obj;
    int b = const_obj[5];

    return 0;
}

工作原理 #

• 当执行obj[3] = 42时：operator[]返回Proxy对象，随后调用Proxy的operator=，触发写操作逻辑。
• 当执行int a = obj[3]时：operator[]返回Proxy对象，随后调用Proxy的operator int()转换运算符，触发读操作逻辑。
• 对于const对象，我们重载了const版本的operator[]，直接返回const int&，确保const场景下只能读不能写。

注意事项 #

• 代理类要正确维护对父对象的引用，避免出现悬空引用（比如父对象被销毁后代理对象还被使用）。
• 如果需要支持更多类型（比如非int），可以把代理类改成模板类，或者扩展转换运算符和赋值运算符的参数类型。

内容的提问来源于stack exchange，提问作者Moriarty