表达式必须在指针上有指针类型错误？

Question

所以我正在创建一个程序，必须使用 2D 动态数组来加/乘/减矩阵。我已经完成了整个程序，但我的析构函数给了我一些问题。尝试释放内存时，我收到错误“表达式必须具有指针类型”，即使我相信它已经是一个指针？非常感谢您的帮助。

类：

#ifndef matrixType_H
#define matrixType_H

class matrixType
{
    friend std::ostream& operator<<(std::ostream& osObject, const matrixType& cObject);

public:
    void setValues(int**, int**, int, int, int, int);
    void addMatrices();
    void subtractMatrices();
    void multiplyMatrices();
    void printMatrix();
    matrixType operator+(const matrixType& object);
    matrixType operator-(const matrixType& object);
    matrixType operator*(const matrixType& object);
    const matrixType& operator=(const matrixType& object);
    matrixType(const matrixType& object);
    matrixType();
    ~matrixType();

private:
    int row1;
    int row2;
    int col1;
    int col2;
    int **matrixPointer1;
    int **matrixPointer2;

};

#endif

根据要求，在从源文件获取用户输入后“设置”我的指针的函数。源文件还包含我复制到类中的 2 个 int** 指针

void matrixType::setValues(int **matrix1, int **matrix2, int r1, int r2, int c1, int c2)
{
    row1 = r1;
    row2 = r2;
    col1 = c1;
    col2 = c2;

    matrixPointer1 = matrix1;
    matrixPointer2 = matrix2;
}

给我带来问题的函数：

matrixType::~matrixType()
{
    for (int i = 0; i < row1; i++){
        for (int j = 0; j < col1; j++)
            delete[]matrixPointer1[i][j]; //Error: Expression must have pointer type

        delete[]matrixPointer1[i];
    }

    for (int i = 0; i < row2; i++){
        for (int j = 0; j < col2; j++)
            delete[]matrixPointer2[i][j]; //Error: Expression must have pointer type

        delete[]matrixPointer2[i];
    }

    delete[]matrixPointer1;
    delete[]matrixPointer2;
}

Answer 1

由于你没有提供分配内存的代码，我只能给你一个很好的猜测：

我假设在matrixType 之外的某个地方，您正在做的事情是：

int** matrix = new int[width];
for (int i = 0; i < width; ++i)
{
    matrix[i] = new int[height];
}

在这种情况下，匹配的解除分配将如下所示：

for (int i = 0; i < width; ++i)
{
    delete[] matrix[i];
}

delete[] matrix;

请注意，分散matrix 指针的“所有权”是不好的做法，以后可能会导致各种问题。随着您的程序变得越来越复杂，跟踪谁在使用哪些内存变得越来越困难，并且您最终可能会释放一个稍后被取消引用的指针（导致段错误或未定义的行为）。

一个好的经验法则是将内存的所有权保持在创建它的范围内。

例如，如果您有一个分配一些内存的对象，则该对象的析构函数应该负责释放它：

// example
class Vector
{
public:
     Vector(int size)
     { data = new int[size]; }

     ~Vector()
     { delete[] data; }

private:
     int* data;
};

同样，如果你在一个函数中分配一些内存，然后将一个指针传递给另一个函数或作用域，创建函数应该负责释放该内存：

// example
void foo()
{
    int* an_array = new int[10];
    process_array(an_array);
    delete[] an_array; // <-- we allocated in this scope, so we free in this scope
}