Question

我的类有一个名为A的通用指针成员：

T** A

目前，我按以下方式删除析构函数中的数组：

~MyQuickInitArray(){
    delete [] A;
};

这会导致内存泄漏吗？如果是这样，我应该遍历数组并在每个对象上调用delete吗？

旁注 - 如果delete [] B是一个整数数组，或者析构函数是否已经处理它，我是否需要调用B？

修改

这是分配的方式：

MyQuickInitArray(int size)
{
    if(size <= 0)
    {
        throw new std::exception;
    }

    _size = size;
    _counter = 0;
    A = new T*[size];
    B = new int[size];
    C = new int[size];
}
    MyQuickInitArray(const MyQuickInitArray& myQuickInitArray)
    {
        _size = myQuickInitArray._size;
        _counter = myQuickInitArray._counter;
        A = new T*[_size];

        for(int i = 0; i<_size ;i++)
        {
            if(myQuickInitArray.A[i] != NULL)
            {
                A[i] = new T(*myQuickInitArray.A[i]);
            }
        }

        B = myQuickInitArray.B;
        C = myQuickInitArray.C;
    }

Answer 1

这会导致内存泄漏吗？

如果A是一个指针数组，你肯定可以依赖它。你需要循环遍历数组并自己删除指针。

~MyQuickInitArray {
    for (int i =_size; i--;) {
        delete A[i];
    }
    delete [] A;
}

如果delete [] B是一个整数数组，或者析构函数是否处理它，我是否需要调用B？

是，始终删除分配有new的内容。您可以在类的析构函数中执行此操作。

Answer 2

这会导致内存泄漏吗？

是的，在没有删除单个元素指向的项目的情况下调用指针数组上的delete[]将导致内存泄漏，因为C ++的“内置”指针没有所有权语义。考虑使用“智能”指针，例如unique_ptr<T>而不是“普通”，以避免在循环中调用析构函数。

如果B是整数数组
，是否需要调用delete [] B.

无论数组的元素类型如何，您都需要在delete[]分配的所有内容上调用new[]。

如何删除指向泛型类型对象的指针数组

2 个答案: