C++ 在同一指针上调用new[]两次而不在其间调用delete[]是否会导致内存泄漏？

我听说每当你使用“new”时，你通常应该“delete”，然而当我运行一个简单的测试程序（如下）时，我为arraySize或numloop输入的数字似乎没有什么区别。这会导致内存泄漏吗

#include <iostream>

int main()
{
    double *array;
    const int arraySize = 100000;
    const int numLoops = 100000;

    for (int i = 0; i < numLoops; i++)
    {
        // do I need to call "delete [] array;" here?
        array = new double[arraySize];
    }

    int x;
    std::cin >> x; // pause the program to view memory consumption

    delete [] array;

    return 0;
}

#包括
int main（）
{
双*阵列；
常数int arraySize=100000；
常量int numLoops=100000；
for（int i=0；i>x；//暂停程序以查看内存消耗
删除[]数组；
返回0；
}

是。您不会对指针调用

new

，而是调用

new

，它会返回一个指向已分配内存的指针。您负责保留该指针并将其删除。如果您覆盖了该值，那么您就是在泄漏。

是。您不会对指针调用

new

，而是调用

new

，它会返回一个指向已分配内存的指针。您负责保留该指针并将其删除。如果您覆盖了该值，那么您正在泄漏。

每当您

新建
（或
新建[]
）内存时，您必须
删除它（或
删除[]
），否则它将泄漏

每次调用new时，如果
new
操作成功，就会返回一个指向堆分配对象的指针。如果指向此内存的指针超出范围或被重新分配（即，您在此处执行的操作），则以后将无法删除该内存

在您的代码示例中，只有最后分配的内存将被销毁。您可以使用诸如process explorer甚至任务管理器之类的工具来检查内存泄漏。
每当您
新建
（或
新建[]
）内存时，必须
删除它（或
删除[]
），否则它将泄漏

每次调用new时，如果
new
操作成功，就会返回一个指向堆分配对象的指针。如果指向此内存的指针超出范围或被重新分配（即，您在此处执行的操作），则以后将无法删除该内存

在您的代码示例中，只有最后分配的内存将被销毁。您可以使用process explorer甚至任务管理器之类的工具来检查内存泄漏。
不，这还不够

每次调用
new
或
new[]
时，都会分配一些内存，并向您提供该内存的地址（以便能够使用它）。每个内存块最终都必须是
delete
d（或
delete[]
d）

您将该地址存储在
数组中，但在下一次迭代中会立即覆盖它。因此，您无法删除分配给您的所有内存。因此您存在内存泄漏。
不，这是不够的

每次调用
new
或
new[]
时，都会分配一些内存，并向您提供该内存的地址（以便能够使用它）。每个内存块最终都必须是
delete
d（或
delete[]
d）

您将该地址存储在
数组中，但在下一次迭代中会立即覆盖它。因此，您无法删除分配给您的所有内存。因此，您存在内存泄漏。
正确理解您实际正在做的事情会有帮助

您没有在同一指针上两次调用
new[]
。您正在两次调用
new[]
，并将两个结果存储到同一个指针中
new[]
只返回一个指向已分配内存的指针。为了避免内存泄漏，您必须在某个时候再次释放该内存。但是指针不是内存，它只是一个指针，告诉你分配的内存在哪里

因此，您可以始终覆盖指针，将其设置为指向新的、不同的地址。然后你就完全不知道它过去指向哪里了。如果它用来指向你应该释放的内存，那么你就再也找不到那块内存了，所以你再也不能对它调用
delete[]
，等等。。。它被泄露了。
这有助于正确理解您实际上在做什么

您没有在同一指针上两次调用
new[]
。您正在两次调用
new[]
，并将两个结果存储到同一个指针中
new[]
只返回一个指向已分配内存的指针。为了避免内存泄漏，您必须在某个时候再次释放该内存。但是指针不是内存，它只是一个指针，告诉你分配的内存在哪里

因此，您可以始终覆盖指针，将其设置为指向新的、不同的地址。然后你就完全不知道它过去指向哪里了。如果它用来指向你应该释放的内存，那么你就再也找不到那块内存了，所以你再也不能对它调用
delete[]
，等等。。。它泄漏了。
是的。幸运的是，有一种更好的方法——不用直接分配内存，而是使用
std:：vector
：

#include <iostream>
#include <vector>

int main()
{
    double *array;
    const int arraySize = 100000;
    const int numLoops = 100000;

    for (int i = 0; i < numLoops; i++)
    {
       std::vector<double> array(arraySize);
       // use it just like a normal array
    }

    int x;
    std::cin >> x; // pause the program to view memory consumption
    return 0;
}

#包括
#包括
int main（）
{
双*阵列；
常数int arraySize=100000；
常量int numLoops=100000；
for（int i=0；i>x；//暂停程序以查看内存消耗
返回0；
}

向量
将在循环的每次迭代中被销毁（并释放它控制的内存）

除非您确实需要，否则一般不应该使用
new
。我甚至可以说，没有必要（甚至没有充分的理由）使用
new
的数组形式。幸运的是，有更好的方法--
#include <iostream>

int main()
{
    double *array;
    double *array2;
    const int arraySize = 100000;

    for (int i = 0; i < 2; i++)
    {
        // do I need to call "delete [] array;" here?
        array = new double[arraySize];
        if(i == 0)
        {
            array2 = array;
        }
    }

    int x;
    std::cin >> x; // pause the program to view memory consumption

    delete [] array;
    delete [] array2;

    return 0;
}