C++重载()运算符：动态数组左值右值访问区分问题

首先得明确你遇到的核心问题：C++的重载决议不会根据函数返回值的使用方式（是作为左值赋值还是右值读取）来选择重载版本。你的test对象x是非const对象，所以即使你是在读取（比如cout << x(20)），编译器会优先匹配非const版本的operator()——因为非const对象可以调用const和非const成员函数，而非const版本的返回值int&可以隐式转换为int，完全符合输出的需求，所以编译器不会去选const版本。

a) 不使用代理对象能否解决该问题？ #

很难完美实现你的需求。

原因在于：C++的重载决议只看调用时的上下文（比如对象是否const、参数类型/数量），根本不关心你调用函数后是要赋值还是读取。对于非const对象，读取操作的语法x(index)和赋值操作的语法x(index)=val完全一样，编译器无法区分你的意图。

如果硬要不用代理，只能通过修改接口来区分读写：

• 比如分开用两个不同的成员函数：int get(int idx) const（负责读取，越界抛异常）和void set(int idx, int val)（负责赋值，自动扩容）；
• 或者重载不同的运算符，比如用[]做读取（const版本），()做赋值（非const版本）。

但这些方法都放弃了用同一个()运算符同时支持读写的初衷，所以算不上“完美解决”你的原始需求。

b) 使用代理对象的实现方案 #

代理对象是这类场景的标准解决方案——它能帮你区分“赋值”和“读取”两种上下文。核心思路是：让operator()返回一个代理类对象，而不是直接返回int&或int，由代理类来处理后续的赋值或读取操作。

修改后的完整代码 #

#include <iostream>
using namespace std;

class test {
private:
    int* myvar;
    int sz;

    // 内部代理类，负责区分读写操作
    class proxy {
    private:
        test& parent;
        int index;
    public:
        proxy(test& p, int idx) : parent(p), index(idx) {}

        // 处理赋值操作：触发原对象的扩容逻辑
        proxy& operator=(int value) {
            parent.assign(index, value);
            return *this;
        }

        // 处理读取操作：触发原对象的越界检查逻辑
        operator int() const {
            return parent.get(index);
        }
    };

public:
    test() : sz(10), myvar(new int[10]()) {} // 初始化数组元素为0
    ~test() { delete[] myvar; } // 新增析构函数，避免内存泄漏
    test(const test&) = delete; // 禁用拷贝构造，简化内存管理
    test& operator=(const test&) = delete; // 禁用赋值运算符

    void dump() const {
        for(int i = 0; i < sz; i++) {
            cout << myvar[i] << " ";
        }
        cout << endl;
    }

    // 单独提取赋值逻辑：负责扩容+赋值
    void assign(int index, int value) {
        if(index >= sz) {
            int* newvar = new int[index+1](); // 新元素初始化为0
            for(int i = 0; i < sz; i++) {
                newvar[i] = myvar[i];
            }
            delete[] myvar;
            myvar = newvar;
            sz = index+1;
        }
        myvar[index] = value;
    }

    // 单独提取读取逻辑：负责越界检查+返回值
    int get(int index) const {
        if(index >= sz) {
            throw "index exceeds dimension";
        }
        return myvar[index];
    }

    // 非const对象调用：返回代理对象，支持读写
    proxy operator()(int index) {
        return proxy(*this, index);
    }

    // const对象调用：只能读取，直接触发越界检查
    int operator()(int index) const {
        return get(index);
    }
};

int main() {
    test x;
    x.dump(); // 输出10个0

    x(1) = 7;
    x(9) = 99;
    x.dump(); // 输出：0 7 0 0 0 0 0 0 0 99

    cout << x(1) << endl; // 输出7
    cout << x(9) << endl; // 输出99

    x(15) = 15;
    x.dump(); // 输出：0 7 0 0 0 0 0 0 0 99 0 0 0 0 0 15

    try {
        cout << x(20) << endl; // 触发异常：index exceeds dimension
    } catch(const char* msg) {
        cerr << "Error: " << msg << endl;
    }

    x.dump(); // 数组大小还是16，不会被扩容
    return 0;
}

代理类的工作逻辑 #

1. 当你执行x(index) = val时：
   • x.operator()(index)返回一个proxy对象；
   • 接着调用proxy::operator=(val)，内部会调用test::assign()，完成扩容和赋值。
2. 当你执行cout << x(index)时：
   • x.operator()(index)返回一个proxy对象；
   • 编译器需要把proxy转换为int，所以调用proxy::operator int()，内部会调用test::get()，触发越界检查，符合预期抛异常。

另外我还修复了原代码的几个小问题：

• 新增析构函数避免内存泄漏；
• 使用new int[N]()初始化数组元素为0（原代码的new int[10]会留下垃圾值）；
• 禁用了拷贝构造和赋值运算符，避免浅拷贝导致的内存问题。

内容的提问来源于stack exchange，提问作者T. Pluess