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

Expression must have pointer type error on a pointer?

本文关键字：指针 类型 错误 表达式      更新时间：2023-10-16

所以我正在创建一个程序，必须使用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;
}

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

我假设在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指针的"所有权"是一种不好的做法，以后可能会导致各种问题。随着程序变得越来越复杂，跟踪谁在使用什么内存变得越来越困难，您可能最终会释放一个稍后被取消引用的指针（导致segfault或未定义的行为）。

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

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

// 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
}
相关文章：