在向量中创建的新数组是否需要使用删除？

Question

我正在尝试为 void** 数据数组创建一些动态数组。

std::vector<void*> data;
data.push_back(new double[1024]);  // array of doubles
data.push_back(new short[1024]);   // array of shorts

为了清理，我应该只使用

data.clear();

或者是否需要删除每个新的，如果需要，如何完成？

Answer 1

为了清理我应该使用

data.clear();

这将从向量中删除所有指针。如果其中任何一个是唯一指向它们各自的动态对象的副本，那么这些对象就不能再被销毁，也不能释放它们的内存。这称为内存泄漏。

或者是否需要删除每个新的

是的。每次执行new[] 表达式时，必须恰好有一个delete[]。如果没有delete[]，则说明存在泄漏。

如果是这样，那是怎么做的？

您只需删除每个指针。您必须格外小心，不要在不先删除它的情况下意外覆盖或删除该向量的元素。您还必须注意不要多次删除相同的元素（或其副本）。

此外，不能删除指向void 的指针。指向 void 的指针可以转换为任何数据指针类型，但您必须知道每个元素的类型。一个工作示例

delete[] static_cast<double*>(data[0]);
delete[] static_cast<short* >(data[1]);

存储拥有内存的裸指针通常是一个非常糟糕的主意——为此使用指向void 的指针更是如此。更好的设计是将动态数组存储在 RAII 容器中，例如std::vector：

std::vector<double> doubles(1024);
std::vector<short>  shorts (1024);
std::vector<void*>  data{doubles.data(), shorts.data()};

这样数组归向量所有，内存由std::vector的代码管理。您必须注意，只要data 的元素仍然指向它们，就不能破坏doubles 和shorts。

Answer 2

不，这行不通

很抱歉直截了当，但是像您一样使用void* 是一种非常糟糕的做法。这种类似 C 的快捷方式在 C++ 中无法正常工作，至少在您使用其他基本类型的数组时不会！

因为将指向对象的指针强制转换为 void 指针，所以编译器无法生成 C++ 对象生命周期所需的代码。

所以让我们使用一个帮助类来演示问题所在：

class C1 {
public: 
    C1() { cout<<"  C1 object constructed"<<endl; } 
    ~C1() { cout<<"  C1 object destroyed"<<endl; }
};

Here 问题的在线演示，我将在以后逐步解释。

案例1：使用指针手动分配

在数组中分配的每一个C1，都会被创建和销毁，简单的代码如下：

C1 *p = new C1[2];   // every new []
delete[] p;          // requires delete[]

案例 2：手动分配推入指针向量：

当一个向量被销毁或被清除时，它的内容也会被销毁。但是，使用指针向量时，指针会被销毁，而不是指向的对象：

所以这行不通；它会泄漏内存：

   vector<C1*> v; 
   v.push_back(new C1[2]);   // C1 objects are created 
   v.clear();                // pointers are lost but C1 objects are not derleted.  

如果在clear之前插入如下语句，一切都OK了：所有创建的C1都被销毁了：

   for (auto &x:v)
       delete[]x; 
   v.clear(); 

案例 3：void* 替代方案注定要失败：

如果我们采用上面的工作代码，但使用转换为void*，C1 对象会被创建，但不会被销毁：

std::vector<void*> data;
data.push_back(new C1[2]);   // yes, creating works and ponter is in ector
for (auto &x:data) 
       delete[]x;           // ouch, deletes a void* so it doesn't know that it's a C1 object
data.clear();

如何解决？

嗯，您需要为存储在向量中的对象提供一个公分母，例如：

• 对所有元素使用继承和公共基类型。
• 使用带有类型选择器的联合，以便能够知道指向的对象的类型
• 使用boost::variant对象

如果您有一个通用的基本类型，您可以考虑使用向量替代向量来摆脱手动内存管理。

Answer 3

是的，对于您的情况，您必须通过operator delete 明确释放它们。但是，由于您似乎想要存储指向不同类型数组的指针，您打算如何区分它们？

忽略这一事实，您的示例代码尖叫std::unique_ptr

Answer 4

经验法则是删除您使用new 分配的所有内容 当您传递使用new[] 分配的数组的引用时，您必须使用delete[] 删除它。但是三思而后行，您正在错误地使用分配的引用....因为您没有将其保存在任何地方，而vector 也没有，它只是可以导航另一个容器（如果可迭代）来制作所有的副本其他容器元素（这是一种在一堆中添加多个项目的便捷方法），因此您将丢失数组引用并造成内存泄漏。 **并且您使用的 array<void*> 与 double 类型不兼容（void* 与 double 类型不同）vector 没有构造函数来传递基本类型的数组元素。它应该有一个像

这样的构造函数吗

vector::vector<T>(const T v[], const size_t sz);

然后您可以使用以下命令初始化vector<double>：

const double initial[] = { 109.8, 98.5, 87.5 };
const size_t initial_sz = sizeof initial / sizeof initial[0];
vector<double> v(initial, initial_sz);

但是你没有这个构造函数，所以你必须使用另一种方法，比如：

vector<double> v;
v.push_back(109.8);
...
v.push_back(87.5);

如果你有另一个可迭代容器，获取迭代器并将其传递给它：

vector<double> v(another_double_container.begin(), another_double_container.end());

但是double [] 数组没有这样的迭代器，因此您不能使用doubles 数组遵循这种方法。

另一个问题是你试图在你的向量中包含不同的类型，它只允许相同类型的实例。您不能（而且编译器不允许您这样做）将不同的类型存储到向量中（因为它将元素连续存储在数组中）