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

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; }
};

这是一个问题的在线演示，我将在下文中逐步解释。

案例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之前插入以下语句，则一切都可以了：所有创建的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 []数组没有这样的迭代器，所以你不能用double的数组来跟这个方法。

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