blocks|key|1306413|text|对于使用new创建的单个对象，delete运算符会释放内存并调用析构函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1306414|delete+[]操作符为使用new+[]创建的对象数组释放内存并调用析构函数。|1306415|在new+[]返回的指针上使用delete，或在new返回的指针上使用delete+[]会导致未定义的行为。|1306416|entityMap^0|4|3|F|6|0|0|9|F|6|0|1|6|F|6|O|3|Z|9|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|K|$]]

The <code>delete</code> operator deallocates memory and calls the destructor for a single object created with <code>new</code>.

The <code>delete []</code> operator deallocates memory and calls destructors for an array of objects created with <code>new []</code>.

Using <code>delete</code> on a pointer returned by <code>new []</code> or <code>delete []</code> on a pointer returned by <code>new</code> results in undefined behavior.

blocks|key|1091259|text|操作符delete和delete+[]分别用于销毁使用new和new[]创建的对象，返回到分配给编译器内存管理器的可用内存。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1091260|使用new创建的对象必须使用delete销毁，使用new[]创建的阵列应该使用delete[]删除。|1091261|entityMap^0|3|6|A|9|R|3|V|5|0|2|3|E|6|P|5|13|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|I|$]]

The operators <code>delete</code> and <code>delete []</code> are used respectively to destroy the objects created with <code>new</code> and <code>new[]</code>, returning to the allocated memory left available to the compiler's memory manager.

Objects created with <code>new</code> must necessarily be destroyed with <code>delete</code>, and that the arrays created with <code>new[]</code> should be deleted with <code>delete[]</code>.

blocks|key|1091363|text|delete[]运算符用于删除数组。delete运算符用于删除非数组对象。它分别调用operator+delete[]和operator+delete函数来删除数组或非数组对象在(最终)调用数组元素或非数组对象的析构函数后所占用的内存。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1091364|下面显示了这些关系：|1091365|typedef+int+array_type[1];

//+create+and+destroy+a+int[1]
array_type+*a+=+new+array_type;
delete+[]+a;

//+create+and+destroy+an+int
int+*b+=+new+int;
delete+b;

//+create+and+destroy+an+int[1]
int+*c+=+new+int[1];
delete[]+c;

//+create+and+destroy+an+int[1][2]
int+(*d)[2]+=+new+int[1][2];
delete+[]+d;|code-block|syntax|javascript|1091366|对于创建数组的new+(因此，new+type[]或应用于数组类型构造的new+)，标准在数组的元素类型类或全局作用域中查找operator+new[]，并传递请求的内存量。如果需要，它可能会请求比N+*+sizeof(ElementType)更多的内容(例如，存储元素的数量，这样在以后删除时，它就知道要完成多少析构函数调用)。如果类声明了一个除了内存量之外还接受另一个size_t的operator+new[]，那么第二个参数将接收分配的元素数量-它可以将该元素用于任何它想要的目的(调试等)。|1091367|对于创建非数组对象的new，它将在元素的类或全局作用域中查找operator+new。它传递请求的内存量(始终为sizeof(T)+)。|1091368|对于delete[]，它检查数组的元素类类型并调用它们的析构函数。使用的operator+delete[]函数是元素类型的类中的函数，如果没有，则在全局范围内。|1091369|对于delete，如果传递的指针是实际对象类型的基类，则基类必须具有虚拟析构函数(否则，行为未定义)。如果它不是基类，则调用该类的析构函数，并使用该类或全局operator+delete中的operator+delete。如果传递了基类，则调用实际对象类型的析构函数，并使用在该类中找到的operator+delete，如果没有，则调用全局operator+delete。如果类中的operator+delete有第二个size_t类型的参数，它将接收要释放的元素的数量。|1091370|entityMap^0|0|8|I|6|16|H|1O|F|0|0|0|7|3|F|A|10|3|1Q|E|2R|N|56|6|5D|E|0|A|3|U|C|1K|9|0|2|8|10|H|0|2|6|26|F|2N|F|40|F|4Q|F|5B|F|5U|6|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|C]|$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|2D|8|@]|D|@]|E|$]]]|V|$]]

The <code>delete[]</code> operator is used to delete arrays. The <code>delete</code> operator is used to delete non-array objects. It calls <code>operator delete[]</code> and <code>operator delete</code> function respectively to delete the memory that the array or non-array object occupied after (eventually) calling the destructors for the array's elements or the non-array object. 

The following shows the relations:

<pre><code>typedef int array_type[1];

// create and destroy a int[1]
array_type *a = new array_type;
delete [] a;

// create and destroy an int
int *b = new int;
delete b;

// create and destroy an int[1]
int *c = new int[1];
delete[] c;

// create and destroy an int[1][2]
int (*d)[2] = new int[1][2];
delete [] d;
</code></pre>

For the <code>new</code> that creates an array (so, either the <code>new type[]</code> or <code>new</code> applied to an array type construct), the Standard looks for an <code>operator new[]</code> in the array's element type class or in the global scope, and passes the amount of memory requested. It may request more than <code>N * sizeof(ElementType)</code> if it wants (for instance to store the number of elements, so it later when deleting knows how many destructor calls to done). If the class declares an <code>operator new[]</code> that additional to the amount of memory accepts another <code>size_t</code>, that second parameter will receive the number of elements allocated - it may use this for any purpose it wants (debugging, etc...). 

For the <code>new</code> that creates a non-array object, it will look for an <code>operator new</code> in the element's class or in the global scope. It passes the amount of memory requested (exactly <code>sizeof(T)</code> always). 

For the <code>delete[]</code>, it looks into the arrays' element class type and calls their destructors. The <code>operator delete[]</code> function used is the one in the element type's class, or if there is none then in the global scope. 

For the <code>delete</code>, if the pointer passed is a base class of the actual object's type, the base class must have a virtual destructor (otherwise, behavior is undefined). If it is not a base class, then the destructor of that class is called, and an <code>operator delete</code> in that class or the global <code>operator delete</code> is used. If a base class was passed, then the actual object type's destructor is called, and the <code>operator delete</code> found in that class is used, or if there is none, a global <code>operator delete</code> is called. If the <code>operator delete</code> in the class has a second parameter of type <code>size_t</code>, it will receive the number of elements to deallocate.

blocks|key|1306575|text|delete用于单个指针，delete[]用于通过指针删除数组。This可能会帮助您更好地理解。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1306576|entityMap|0|LINK|mutability|MUTABLE|url|http://techieswagger.com/technology/memory-management-c-plus-plus/^0|0|6|D|8|W|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

<code>delete</code> is used for one single pointer and <code>delete[]</code> is used for deleting an array through a pointer.
<a href="http://techieswagger.com/technology/memory-management-c-plus-plus/" rel="nofollow noreferrer">This</a> might help you to understand better.

blocks|key|1306616|text|当我问这个问题时，我真正的问题是，“两者之间有区别吗?运行时不需要保存有关数组大小的信息，所以它不能区分我们指的是哪一个？”这个问题没有出现在“相关问题”中，所以为了帮助像我这样的人，这里有一个答案："why+do+we+even+need+the+delete[]+operator?"|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1306617|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/252515/why-do-we-even-need-the-delete-operator^0|2S|18|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

When I asked this question, my real question was, "is there a difference between the two? Doesn't the runtime have to keep information about the array size, and so will it not be able to tell which one we mean?" This question does not appear in "related questions", so just to help out those like me, here is the answer to that: <a href="https://stackoverflow.com/questions/252515/why-do-we-even-need-the-delete-operator">"why do we even need the delete[] operator?"</a>

What is the difference between <code>delete</code> and <code>delete[]</code> operators in C++?

问在C++中删除vs delete[]运算符
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中删除vs delete[]运算符EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中删除vs delete[]运算符
EN