如何区分处理左值与右值上下文的[]运算符？

当然可以实现！你遇到的问题其实是C++里常见的运算符重载场景——默认情况下，non-const对象的operator[]不管是出现在赋值左边（左值）还是右边（右值），都会调用同一个非const版本。要区分这两种上下文，我们有两种解决方案，取决于你的具体需求：

方案1：区分const/non-const对象的调用（基础版） #

首先纠正你之前的编译错误：你尝试声明的unsigned const & test::operator [](unsigned const idx)之所以编译不通过，大概率是因为没在成员函数末尾加const。C++里区分operator[]的const重载，关键是成员函数本身是否为const，而不是返回值或参数的const修饰。

正确的重载写法应该是这样：

class Test {
private:
    unsigned data[10];
public:
    // 非const对象调用：可作为左值（赋值）或右值（取值）
    unsigned& operator[](unsigned idx) {
        return data[idx];
    }

    // const对象调用：只能作为右值（取值），不能赋值
    const unsigned& operator[](unsigned idx) const {
        return data[idx];
    }
};

这个方案能区分const对象和non-const对象的[]调用：当你用const Test对象时，会自动调用const版本，无法作为左值赋值；non-const对象则调用非const版本，既可以赋值也可以取值。但它不能区分non-const对象的左值和右值上下文——比如t[0] = a和a = t[0]都会调用同一个非const版本。

方案2：区分non-const对象的左/右值上下文（进阶版） #

如果需要对non-const对象的[]左值、右值操作分别做不同处理，就得用代理模式（Proxy Pattern）。核心思路是让operator[]返回一个代理对象，而非直接返回引用，通过代理类的重载运算符来区分赋值和取值行为。

举个完整的例子：

#include <iostream>

class Test; // 提前声明Test类

// 代理类：负责处理[]的左值和右值逻辑
class TestProxy {
private:
    Test& parent;
    unsigned idx;
public:
    TestProxy(Test& p, unsigned i) : parent(p), idx(i) {}

    // 处理左值上下文：t[0] = a; 触发这个operator=
    TestProxy& operator=(unsigned val) {
        std::cout << "执行左值赋值逻辑，索引" << idx << "设为" << val << std::endl;
        // 这里写你的左值处理逻辑，比如修改原对象的内部数据
        parent.setData(idx, val);
        return *this;
    }

    // 处理右值上下文：a = t[0]; 触发这个类型转换运算符
    operator unsigned() const {
        std::cout << "执行右值取值逻辑，获取索引" << idx << "的值" << std::endl;
        // 这里写你的右值处理逻辑，比如读取原对象的内部数据
        return parent.getData(idx);
    }
};

class Test {
private:
    unsigned data[10] = {0};
public:
    // non-const对象的operator[]返回代理
    TestProxy operator[](unsigned idx) {
        return TestProxy(*this, idx);
    }

    // const对象的operator[]直接返回const引用（保持const正确性）
    const unsigned& operator[](unsigned idx) const {
        return data[idx];
    }

    // 供代理类调用的内部方法（也可以把代理类声明为友元来直接访问data）
    void setData(unsigned idx, unsigned val) {
        if (idx < 10) data[idx] = val;
    }

    unsigned getData(unsigned idx) const {
        if (idx < 10) return data[idx];
        return 0; // 处理索引越界的默认值
    }
};

// 测试代码
int main() {
    Test t;
    t[0] = 100; // 左值上下文：调用TestProxy的operator=
    unsigned a = t[0]; // 右值上下文：调用TestProxy的operator unsigned()
    std::cout << "a的值是：" << a << std::endl;

    const Test ct;
    unsigned b = ct[1]; // const对象：调用const版本的operator[]
    std::cout << "b的值是：" << b << std::endl;
    return 0;
}

运行这段代码会输出：

执行左值赋值逻辑，索引0设为100
执行右值取值逻辑，获取索引0的值
a的值是：100
b的值是：0

这样就完美区分了non-const对象的左值和右值上下文操作，同时也保持了const对象的正确性。

总结 #

• 若只需区分const/non-const对象的[]调用：用const成员函数重载，记得在成员函数末尾加const。
• 若要区分non-const对象的左值/右值操作：使用代理类，通过代理的operator=处理赋值，类型转换运算符处理取值。

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