如何破坏阵列

#include <cstdlib> 
#include <iostream> 

using namespace std; 

const unsigned long MAX_SIZE = 20; 
typedef int ItemType; 

class Heap { 
private: 
     ItemType array[MAX_SIZE]; 
     int elements; //how many elements are in the heap 
public: 
     Heap() 
     ~Heap() 
     bool IsEmpty() const 
     bool IsFull() const 
     Itemtype Retrieve() 
     void Insert(const Itemtype&) 
};

比方说，我有这个作为我的头文件。在我的这个实现中，执行Heap（）构造函数和〜Heap（）析构函数的最佳方法是什么。如何破坏阵列

我

Heap::Heap() 
{ 
    elements = 0; 
} 

Heap::~Heap() 
{ 
    array = NULL; 
}

我想知道这是否是破坏和建设在这种情况下，一个数组的正确方法。

来源

2009-12-10 bob

你是什么意思破坏？把它归零？或者你的意思是释放？如果你的意思是后者，那么你不必这样做，因为这个数组将被分配到堆栈上并在调用Heap-dtor时释放。 – Christian 2009-12-10 08:23:44

它可以在堆栈上分配，也可以不分配。这完全取决于如何创建堆实例。 – 2009-12-10 10:37:07

你说得对，我应该更精确，并说“当堆实例超出范围/取消分配时，数组将自动释放” – Christian 2009-12-10 13:07:58

array不会动态分配，因此当对象不再存在于作用域中时，它的存储将消失。事实上，你不能重新分配到array;这样做是错误的。

来源

2009-12-10 08:25:16

您不必销毁您的数组，因为它被value使用并且只使用values（int）。

来源

2009-12-10 08:23:06

传递参数时使用的术语不是“按值”吗？也许你的意思是对的，但我觉得你的答案不清楚。 – foraidt 2009-12-10 09:16:03

我的意思是“按价值”，当访问它不是“通过引用”，即直接访问该字段的值。 – 2009-12-10 10:13:21

在dtor中没有什么需要做的，因此你不需要写一个。数组对象的内存不是动态分配的。因此，当Heap对象超出范围时，将自动释放分配给array的内存。

来源

2009-12-10 08:23:28 Naveen

答案有问题吗？很想听到downvote的原因。 – Naveen 2009-12-10 08:29:24

这在技术上是不正确的。数组对象是在分配给Heap类实例的内存块中创建的。因此，只有当堆实例被分配到堆栈上时，才会在堆栈上创建数组对象。如果实例在堆上分配，则该数组对象将位于该块中。 – 2009-12-10 08:30:25

可能我使用术语堆栈松散一点。我的意思是数组对象的内存不是动态分配的，因此不需要显式的内存管理。当封装对象被释放时它会自动清理。 – Naveen 2009-12-10 08:36:21

如果您将typedef更改为基于指针的类型，则应删除数组的每个ItemType。

所以，你可以通过数组迭代并删除它们

for (int i = 0; i < elements; i++) 
    delete array[i] // Supposing you created them with new

来源

2009-12-10 08:25:33 HyLian

如果您更改实现以使用“new”动态分配数组，则需要稍后执行此操作： delete [] array; – SapphireSun 2009-12-10 08:28:50

由于你的数组是静态分配（即不使用new），析构函数实际上并不需要做任何事情 - 只要创建的堆超出范围（如果动态创建，则会明确删除），数组将消失。

只有在动态分配内存时（例如，在C代码中使用new或malloc()），是否需要明确删除（或free()）它。

来源

2009-12-10 08:26:22

“你的数组在静态堆栈中分配” - 这在技术上是不正确的。数组对象是在分配给Heap类实例的内存块中创建的。因此，只有当堆实例被分配到堆栈上时，才会在堆栈上创建数组对象。如果实例在堆上分配，则该数组对象将位于该块中。 – 2009-12-10 08:32:45

啊，好点。它并没有真正改变答案的内容 - 当对象被销毁时，数组将被销毁（如果对象是静态分配的，则超出范围，或者如果分配了对象，则显式删除/释放动态），所以不需要析构函数。 – 2009-12-10 08:41:08

静态数组将具有程序的生命周期。请记住，静态分配不同于自动分配和动态分配。 – 2009-12-10 19:52:33

C++中有两种类型的数组：静态和动态。它们之间的主要区别在于如何为它们分配内存。静态数组或多或少由编译器自动创建和销毁。动态数组需要由程序员创建和销毁。你的对象目前使用静态数组，所以你不需要担心它的创建或销毁。

typedef int ItemType; 
ItemType *array; // Pointer to location in memory where the array will reside. 

Heap::Heap() 
{ 
    array = new ItemType[MAX_SIZE]; // Assign memory for the array to use. 
    elements = 0; 
} 

Heap::~Heap() 
{ 
    delete[] array; // Clear the memory used by the array. 
}

来源

2009-12-10 08:31:02 Swiss

创建/构建/分配数组，而不是“分配”。你不能在C++ – jalf 2009-12-10 12:11:43

中分配数组哦，并且数组不是静态的。这是一个非静态类成员。 – jalf 2009-12-10 12:12:15

澄清，在C++中只有一种数组。有多种存储。数组的功能不取决于它所在的位置;只有它的一生。在执行离开函数之前，在函数中声明的数组一直处于活动状态。一个动态数组一直处于活动状态，直到它被释放或程序终止。 – 2009-12-10 19:50:33

阵列就像在你原来的例子是你Heap类的子对象：

但是，如果你想你的阵列切换到动态数组，可以按如下方式改变你的代码。它由Heap构造函数自动构造，并由Heap析构函数自动构造。你不需要做任何事情来构建和/或破坏它。

来源

2009-12-10 08:34:47 AnT

如何破坏阵列

回答

相关问题