C++；创建阵列时内存泄漏 在我的C++游戏中，我有一组指针指向代码>我使用可视泄漏检测器检测内存泄漏，它告诉我以下代码中存在泄漏： vector<EnemyType*> enemyTypes(number_of_lines); for (int i = 0; i < number_of_lines; i++) { enemyTypes[i] = new EnemyType(); } vector enemyTypes（行数）； 对于（int i=0；i

假设在这种情况下，

行数

为3。我怎么可能在这里制造了一个漏洞？我能做点什么吗

我大约一个月前开始学习C++，我每天还在学习，但是我没有一些人解释我不能理解一些东西。

---

编辑：我修改了代码，使用矢量而不是普通数组。

从原始代码：

EnemyType** enemyTypes{ new EnemyType*[number_of_lines] };

for (int i = 0; i < number_of_lines; i++)
{
    enemyTypes[i] = new EnemyType();
}

根据您使用数据的方式，您甚至可以避免使用指针：

#include <vector>
#include <memory>

// ...

std::vector<std::unique_ptr<EnemyType>> enemy_types(number_of_lines);

for (auto& enemy_type : enemy_types)
{
    enemy_type = std::make_unique<EnemyType>();
}

std::vector<EnemyType> enemy_types(number_of_lines);

std:：向量类型（行数）；

来自原始代码：

EnemyType** enemyTypes{ new EnemyType*[number_of_lines] };

for (int i = 0; i < number_of_lines; i++)
{
    enemyTypes[i] = new EnemyType();
}

根据您使用数据的方式，您甚至可以避免使用指针：

#include <vector>
#include <memory>

// ...

std::vector<std::unique_ptr<EnemyType>> enemy_types(number_of_lines);

for (auto& enemy_type : enemy_types)
{
    enemy_type = std::make_unique<EnemyType>();
}

std::vector<EnemyType> enemy_types(number_of_lines);

std:：向量类型（行数）；

使用“新建”操作符时，请确认已删除所创建的每个对象

---

一个好的替代方法是使用STL或boost库中的智能指针。当对象未使用时，它们将自动删除该对象，从而避免内存泄漏。

使用“新建”操作符时，请验证您是否删除了创建的每个对象

---

一个好的替代方法是使用STL或boost库中的智能指针。当对象未使用时，它们将自动删除对象，从而避免内存泄漏。

操作员

new

动态分配内存

某些代码最终需要使用相应的操作符

delete

释放内存。如果您的代码没有这样做，内存将永远不会释放。如果您的程序失去跟踪（例如，用于保存

new

结果的指针不再存在），这将成为泄漏

稍微修改一下的代码版本

int func()
{
    EnemyType** enemyTypes{ new EnemyType*[number_of_lines] };

    for (int i = 0; i < number_of_lines; i++)
    {
         enemyTypes[i] = new EnemyType();
    }
}

int func（）
{
EnemyType**enemyTypes{new EnemyType*[行数]}；
对于（int i=0；i<行数；i++）
{
EnemyType[i]=新的EnemyType（）；
}
}

当函数返回时，指针

enemyTypes

不再存在（因为它超出了范围）。结果是，首次使用运算符

new

创建的内存永远不会释放，并且不存在指向它的指针。由于无法访问该内存，因此也无法访问循环中运算符

new

的结果（因为存储这些结果的唯一位置是由

enemyTypes

标识的动态分配数组）

---

因此，所有这些内存都会在此时泄漏（动态分配的内存无法由程序恢复，除非您使用标准C++范围之外的技术）。各种内存检查器-如果您使用它们-将相应地报告泄漏。。。。在函数返回点或程序终止时。

运算符

new

动态分配内存

某些代码最终需要使用相应的操作符

delete

释放内存。如果您的代码没有这样做，内存将永远不会释放。如果您的程序失去跟踪（例如，用于保存

new

结果的指针不再存在），这将成为泄漏

稍微修改一下的代码版本

int func()
{
    EnemyType** enemyTypes{ new EnemyType*[number_of_lines] };

    for (int i = 0; i < number_of_lines; i++)
    {
         enemyTypes[i] = new EnemyType();
    }
}

int func（）
{
EnemyType**enemyTypes{new EnemyType*[行数]}；
对于（int i=0；i<行数；i++）
{
EnemyType[i]=新的EnemyType（）；
}
}

当函数返回时，指针

enemyTypes

不再存在（因为它超出了范围）。结果是，首次使用运算符

new

创建的内存永远不会释放，并且不存在指向它的指针。由于无法访问该内存，因此也无法访问循环中运算符

new

的结果（因为存储这些结果的唯一位置是由

enemyTypes

标识的动态分配数组）

---

因此，所有这些内存都会在此时泄漏（动态分配的内存无法由程序恢复，除非您使用标准C++范围之外的技术）。各种内存检查器-如果您使用它们-将相应地报告泄漏。。。。无论是在函数返回的点上，还是程序终止的点上。

结果证明我从未释放内存（正如其他人告诉我的），但VisualLeakDetector只是向我显示了分配内存的位置，而不是泄漏发生的位置。

结果证明我从未释放内存（正如其他人告诉我的），但是VisualLeakDetector只是向我显示了分配内存的位置，而不是泄漏发生的位置。

您是否尝试了vectors？只有当您忘记释放内存时，才会造成泄漏。上面的代码没有显示这个问题。创建一个MCVE：如果

enemyTypes

是某个方法的本地属性，并且您没有

delete

每个元素（以及数组本身），那么您就存在泄漏。考虑使用<代码> STD:：vector ，动态内存并不总是令人讨厌的，当使用时，适当的智能指针可以利用管理部分。这是我为学校所做的一个游戏，还不允许使用智能指针。我曾考虑过使用向量，但出于学习目的，使用普通数组似乎更好，但现在我将重新考虑使用它。使用指针有什么原因吗？您还可以将EnemyType存储在数组中（或者更好：存储在向量中）。您尝试过向量吗？只有当您忘记释放内存时，才会造成泄漏。上面的代码没有显示这个问题。创建一个MCVE：如果

enemyTypes

是某个方法的本地元素，并且您没有

delete

每个元素（以及数组本身），那么您有