C++自定义Array类：重载operator[]后能否支持赋值操作？求方案

你当前的operator[]实现返回的是值类型，这就是没法通过a[5] = 2000修改数组元素的核心原因——当你调用a[5]时，返回的是_content[n]的临时拷贝，赋值操作只会作用在这个临时变量上，根本不会影响原数组里的元素。要支持通过[]直接赋值，需要让operator[]返回引用类型。

简洁解决方案：重载两个版本的operator[] #

在C++中，容器类通常会重载两个版本的operator[]：一个供非const对象使用（返回可修改的引用），另一个供const对象使用（返回只读的const引用），这样既能支持修改操作，又能保证const正确性。

修改后的Array类代码如下：

#include <cassert>
#include <algorithm> // 用于std::fill和std::copy

class Array { 
private: 
    int *_content; 
    unsigned int _size; // 建议添加成员变量记录数组大小，避免越界风险
public: 
    Array(unsigned int n) : _size(n) { 
        this->_content = new int[n]; 
        // 可选：初始化数组元素为0，避免未定义行为
        std::fill(_content, _content + _size, 0);
    } 
    ~Array() { delete[] _content; } 

    // 非const版本：返回可修改的引用，支持赋值操作
    int& operator[](int n) { 
        // 可选：添加越界检查，用断言快速定位问题
        assert(n >= 0 && static_cast<unsigned int>(n) < _size);
        return this->_content[n]; 
    } 

    // const版本：返回只读的const引用，供const对象使用
    const int& operator[](int n) const { 
        assert(n >= 0 && static_cast<unsigned int>(n) < _size);
        return this->_content[n]; 
    } 

    // 补充：你提到已重载赋值运算符，别忘了实现拷贝构造函数
    // 避免浅拷贝导致的double free崩溃问题
    Array(const Array& other) : _size(other._size) {
        _content = new int[_size];
        std::copy(other._content, other._content + _size, _content);
    }

    Array& operator=(const Array& other) {
        if (this != &other) { // 防止自赋值
            delete[] _content;
            _size = other._size;
            _content = new int[_size];
            std::copy(other._content, other._content + _size, _content);
        }
        return *this;
    }
};

测试代码验证 #

修改后你就可以正常使用赋值操作了：

#include <iostream>

int main() { 
    Array a(10); 
    a[5] = 2000; // 现在可以直接给数组元素赋值
    std::cout << a[5] << std::endl; // 输出：2000

    // const对象的场景：只能读取，不能修改
    const Array b(5);
    std::cout << b[2] << std::endl; // 正常输出0
    // b[2] = 100; // 编译错误，符合const正确性要求
    return 0; 
}

额外注意事项 #

1. 越界检查：建议添加断言或抛出异常处理数组越界，避免访问非法内存导致的未定义行为。
2. 浅拷贝问题：因为类持有动态分配的内存，必须实现拷贝构造函数和赋值运算符（即C++的"三法则"），否则对象拷贝时会出现多个对象指向同一块内存，析构时重复释放导致崩溃。

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