如何安全实现支持双方括号访问的Matrix2D矩阵类

这确实是个很实际的问题——既要保留大家熟悉的m[r][c]双括号访问语法，又要防止用户不小心通过修改行向量破坏整个矩阵的结构，直接返回std::vector<double>&确实太不安全了。这里有个非常靠谱的实现思路：用代理类包装行元素的访问，既能维持原有语法习惯，又能牢牢锁住对矩阵结构的修改权限。

核心思路 #

不再让Matrix2D::operator[]直接返回内部行向量的引用，而是返回一个自定义的代理类实例。这个代理类只暴露单个元素的访问接口（重载operator[]），同时禁止任何能修改整个行结构的操作（比如赋值整个向量）。

具体实现代码 #

第一步：定义行代理类 #

我们需要两个代理类，分别对应非const和const版本的矩阵访问：

// 非const矩阵的行代理：允许修改单个元素，但禁止修改行结构
class MatrixRowProxy {
private:
    std::vector<double>& row_;

    // 只有Matrix2D能创建这个代理类，把构造函数设为私有，友元Matrix2D
    friend class Matrix2D;
    explicit MatrixRowProxy(std::vector<double>& row) : row_(row) {}

public:
    // 重载[]，允许访问/修改单个元素，同时做越界检查
    double& operator[](size_t col) {
        if (col >= row_.size()) {
            throw std::out_of_range("Column index out of bounds");
        }
        return row_[col];
    }

    // 禁止赋值整个行的操作：直接删除赋值运算符
    MatrixRowProxy& operator=(const std::vector<double>&) = delete;
    MatrixRowProxy& operator=(std::vector<double>&&) = delete;
};

// const矩阵的行代理：只能读取元素，完全禁止修改
class ConstMatrixRowProxy {
private:
    const std::vector<double>& row_;

    friend class Matrix2D;
    explicit ConstMatrixRowProxy(const std::vector<double>& row) : row_(row) {}

public:
    const double& operator[](size_t col) const {
        if (col >= row_.size()) {
            throw std::out_of_range("Column index out of bounds");
        }
        return row_[col];
    }
};

第二步：修改Matrix2D的operator[] #

把原来返回std::vector<double>&的逻辑改成返回上面的代理类：

class Matrix2D {
private:
    std::vector<std::vector<double>> data_;
    size_t rows_;
    size_t cols_;

public:
    // 构造函数：检查行列合法性，初始化矩阵
    Matrix2D(size_t rows, size_t cols) : rows_(rows), cols_(cols) {
        if (rows == 0 || cols == 0) {
            throw std::invalid_argument("Rows and columns must be positive");
        }
        data_.resize(rows, std::vector<double>(cols, 0.0));
    }

    // 非const版本：返回非const行代理
    MatrixRowProxy operator[](size_t row) {
        if (row >= rows_) {
            throw std::out_of_range("Row index out of bounds");
        }
        return MatrixRowProxy(data_[row]);
    }

    // const版本：返回const行代理
    ConstMatrixRowProxy operator[](size_t row) const {
        if (row >= rows_) {
            throw std::out_of_range("Row index out of bounds");
        }
        return ConstMatrixRowProxy(data_[row]);
    }

    // 提供获取行列数的接口
    size_t rows() const { return rows_; }
    size_t cols() const { return cols_; }
};

为什么这个方案有效？ #

1. 语法完全兼容：用户依然可以像原来一样用m[1][1] = 3.14或者auto val = m[0][2]，没有任何学习成本。
2. 彻底阻止结构修改：因为代理类删除了赋值运算符，像m[0] = std::vector<double>(0)这种企图替换整个行的操作会直接在编译期报错，从根源上杜绝了破坏矩阵结构的可能。
3. 额外的安全保障：我们在代理类的operator[]里添加了越界检查，比std::vector默认的未定义行为更安全，能及时抛出异常提醒用户。

如果想要更严格的控制，还可以在代理类里隐藏所有能获取到整个行向量的接口，确保用户完全没有机会修改行的大小。

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