我如何解决这个内存泄漏

Question

我正在尝试重新创建向量类，我相信我的代码中存在内存泄漏，但我不知道如何解决。 在我的 Visual Studio 中使用 CRT 库，它告诉我有一个假设的内存泄漏，每次调用该保留时都会增加一倍。

我不太确定为什么会这样，或者是否有内存泄漏。 内存泄漏检测说它是保留函数中的这一行int* temp = new int[n];

这就是我所理解的在储备功能中发生的事情：

一旦arr的内容复制到temp中，删除arr就可以了。 分配arr = temp应该可以工作，因为我所做的只是让 arr 指向与 temp 相同的位置。 因为 arr 之前被删除了，所以我在堆中只有 1 个数组，并且 arr 和 temp 都指向同一个数组，所以应该没有内存泄漏。 Temp 应该无关紧要，因为它在退出范围后就会消失。 在对保留函数的后续调用中，每件事都会重复，并且堆中应该只有一个数组 arr 指向。

我确实相信我的想法可能在某些方面是错误的。

    #include "Vector.h"

    namespace Vector {

    vector::vector() {
        sz = 0;
        space = 0;
        arr = nullptr;
    }
    vector::vector(int n) {
        sz = n;
        space = n;
        arr = new int[n];
        for(int i = 0; i < n; i++) {
            arr[i] = 0;
        }
    }
    void vector::push_back(int x) {
        if(sz == 0) {
            reserve(1);
        } else if (sz == space) {
            reserve(2*space);
        }
        arr[sz] = x;
        sz++;
    }
    void vector::reserve(int n) {
        if (n == 1) {
            arr = new int[1]; //arr was a nullptr beforehand
        }
        int* temp = new int[n]; 
        for(int i = 0; i < n; i++) {
            temp[i] = arr[i];
        }
        delete[] arr;
        arr = temp;
        space = n;      
    }

Answer 1

您的代码在vector::reserve(int n)假设arr为null 。

相反，可能会根据arr是否为null来详细说明reserve函数的方式。

void vector::reserve(int n) {
    if (arr) { //handle case when arr is null
        space += n;
        arr = new int[space];
        //no need to copy anything!
    } else { //handle case when arr is not null
        int* tmp(new int[space + n]);
        for(int i = 0; i < space; i++) {
            tmp[i] = arr[i];
        }
        delete[] arr;
        arr = tmp;
        space += n;
    }
}

此外，上面的代码假设您的意思是保留space+n而不是允许reserve来缩小数组，因为如果您保留的数量少于先前的保留，您将丢失数据。 通常更好的做法是在使用指针时不使用关于指针状态的假设，因为当您的代码变得更复杂时，这些假设最终可能会被遗忘或更模糊。

Answer 2

我也有同样的问题。 我创建了两个指向堆中同一地址的指针。 当我试图释放内存时，结果只有一个指针可以做到这一点，它是指向该地址的第一个指针。 指向该地址的第二个或第三个指针没有释放内存的权限，但只有第一个拥有该权限的指针。

例子

int *a = new int[5];
int *b = a;
int *c = a;

指针 b 和 c 没有权限释放指针 a 所指向的内存地址。 因此，如果我说的是delete[] b或delete[] c ，则内存不会被释放，他们没有这样做的权限。 然后我试着写delete [] a并且奏效了。 我没有真正的答案，我只是试图通过我所做的尝试和错误来解决。 这就是我得到的。

其实这种情况是违反规则的，但是C++仍然允许我们这样做，它被称为未定义行为。 我们违反了delete[]运算符的规则，但 C++ 仍然允许您这样做，结果，您得到了意外的输出。

Answer 3

那里没有太多错。

错误

    if (n == 1) {
        arr = new int[1]; //arr was a nullptr beforehand
    }

不能保证评论。 没有什么可以阻止多次调用调整大小，包括调用reserve(1) ，这将泄漏arr指向的任何内存。 而是考虑

    if (arr == nullptr) {
        arr = new int[n]; //arr was a nullptr beforehand
    }

现在评论保证是真实的。

每次增加数组的大小时，复制循环都会超过arr的结尾。

    for(int i = 0; i < n; i++) {
        temp[i] = arr[i];
    }

arr只适用于arr[sz-1] 。 如果n大于space ，而且几乎总是这样， arr[i]就会游荡到Undefined Behavior 的荒野中。 不是一个好去处。

    for(int i = 0; i < n && i < sz; i++) {
        temp[i] = arr[i];
    }

检查n和sz以防止任一端溢出和复制尚未设置的数据。 如果没有什么可复制的，则全部完成。

机会目标

类需要一个析构函数来释放它拥有的任何内存（ 资源或指针的所有权是什么？ ）。 没有它，你就有泄漏。

vector::~vector() {
    delete[] arr;
}

如果它有析构函数，则三规则要求它具有特殊的支持函数来处理（至少）类的复制或明确禁止复制。

// exchanges one vector for the other. Generally useful, but also makes moves 
// and assignments easy
void vector::swap(vector& a, vector& b)
{
    std::swap(a.sz, b.sz);
    std::swap(a.space, b.space);
    std::swap(a.arr, b.arr);
}

// Copy constructor
vector::vector(const vector& src):
    sz(src.sz),
    space (src.space),
    arr(new int[space])
{
    for(int i = 0; i < sz; i++) {
        arr[i] = src.arr[i];
    }
}

// move constructor
vector::vector(vector&& src): vector()
{
    swap(*this, src);
}

// assignment operator
vector::vector& vector::operator=(vector src)
{
    swap(*this, src);

    return *this;
}

Copy Constructor 使用Member Initializer List 。 这很有趣:位。

赋值运算符使用Copy and Swap Idiom 。 这不是实现赋值运算符的最快方法，但它可能是最简单的方法。 从简单开始，只有在最简单的不满足要求时才进行困难。