重载二维数组流插入/提取及()运算符遇错求助

问题1：输入输出运算符匹配错误 #

原因 #

你重载的operator<<和operator>>参数使用了右值引用（const array &&arr、array &&a），但main中arr2是左值，C++不允许将左值绑定到右值引用参数，导致编译器找不到匹配的运算符重载。此外，这两个运算符直接访问了array类的私有成员（row、col、ptr），但未被声明为类的友元，即使参数类型正确也会触发访问权限错误。

解决方法 #

1. 修改运算符参数为左值引用：
   • operator<<接收const左值引用（输出操作不修改对象）
   • operator>>接收非const左值引用（输入操作需要修改对象）
2. 在array类的头文件中，将这两个运算符声明为友元，允许它们访问私有成员。

修改后的运算符实现：

// operator<< 修改为const左值引用参数
std::ostream &operator<<(std::ostream &output, const array &arr) {
    for (size_t i = 0; i < arr.row; i++)
    {
        for (size_t j = 0; j < arr.col; j++)
        {
            output << std::setw(8) << arr.ptr[i][j]; // 用setw格式化输出更美观
        }
        output << std::endl;
    }
    return output;
}

// operator>> 修改为非const左值引用参数
std::istream &operator>>(std::istream &input, array &a) {
    for (size_t i = 0; i < a.row; i++)
    {
        for (size_t j = 0; j < a.col; j++)
        {
            input >> a.ptr[i][j];
        }
    }
    return input;
}

在array.h中添加友元声明：

class array {
    // ... 其他成员 ...
    friend std::ostream &operator<<(std::ostream &output, const array &arr);
    friend std::istream &operator>>(std::istream &input, array &a);
};

问题2：类内部无法用ptr(row, col)访问元素 #

原因 #

ptr是double**类型的指针，不是重载了operator()的对象，自然不能用()运算符调用。你想要的是调用array类自身重载的operator()，而非直接操作指针。另外，当前的operator()只返回元素值，无法用于修改元素，且缺少const版本（const对象无法调用非const的operator()）。

解决方法 #

1. 在类内部访问元素时，调用(*this)(row, col)来使用自身的operator()；
2. 重载两个版本的operator()：非const版本返回引用（支持修改元素），const版本返回const引用（支持const对象访问）；
3. 修复operator()中的逻辑错误：size_t是无符号类型，row < 0永远为假，应该判断row >= this->row || col >= this->col来检查越界。

修改后的operator()实现：

// 非const版本：返回引用，支持修改元素
double& array::operator()(size_t row, size_t col) {
    if (row >= this->row || col >= this->col) {
        throw std::out_of_range("Row or column index out of bounds");
    }
    return ptr[row][col];
}

// const版本：返回const引用，支持const对象访问
const double& array::operator()(size_t row, size_t col) const {
    if (row >= this->row || col >= this->col) {
        throw std::out_of_range("Row or column index out of bounds");
    }
    return ptr[row][col];
}

之后在类内部就可以这样调用：

// 拷贝构造函数中替换ptr[i][j] = arr.ptr[i][j];
ptr[i][j] = arr(i, j);

// initializer_list构造函数中替换ptr[i][j] = *coll;
(*this)(i, j) = *coll;

额外的代码修复建议 #

1. 拷贝构造函数的内存泄漏/崩溃问题：当前代码只初始化了指针数组，未为每行分配内存就直接赋值，会导致未定义行为。需要先为每一行分配内存：

array::array(const array &arr) 
    : row(arr.row), col(arr.col), ptr(new double*[row])
{
    for (size_t i = 0; i < row; i++)
    {
        ptr[i] = new double[col]; // 先分配每行的内存
        for (size_t j = 0; j < col; j++)
        {
            ptr[i][j] = arr(i, j);
        }
    }
}

2. 析构函数的错误：当前delete []*ptr只会释放第一行的内存，导致内存泄漏。需要遍历所有行释放后，再释放指针数组：

array::~array() {
    for (size_t i = 0; i < row; i++) {
        delete[] ptr[i]; // 释放每行的内存
    }
    delete[] ptr; // 释放指针数组
}

3. initializer_list构造函数的问题：如果传入的初始化列表中每行列数不一致，col会被最后一行的列数覆盖，导致后续访问越界。可以添加检查确保所有行的列数相同：

array::array(std::initializer_list<std::initializer_list<double>> list)
    : row(list.size())
{
    if (row == 0) {
        col = 0;
        ptr = nullptr;
        return;
    }
    // 检查所有行的列数是否一致
    col = list.begin()->size();
    for (const auto& r : list) {
        if (r.size() != col) {
            throw std::invalid_argument("All rows must have the same column count");
        }
    }
    ptr = new double*[row];
    size_t i = 0;
    for (const auto& r : list) {
        ptr[i] = new double[col];
        size_t j = 0;
        for (double val : r) {
            (*this)(i, j++) = val;
        }
        i++;
    }
}

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