blocks|key|1196134|text|真的没有理由这样写，而且有一个严肃的理由永远不要这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1196135|确实，对于带有简单析构函数的类型(如本例中的原始指针)，不需要知道数组中元素的实际数量，因此编译器可能会决定将new[]和delete[]映射到new和delete，以减少开销。如果它以这种方式决定，你不能在不采取额外步骤的情况下停止它，所以这个编译器优化将在没有你的通知的情况下发生，并且是免费的。|1196136|同时，使用您的代码的人可能希望重载全局操作符new和delete+(以及new[]和delete[]+)。如果发生这种情况，您会遇到大麻烦，因为此时您可能真的需要delete[]和delete之间的区别。|1196137|此外，这种依赖于编译器的优化是不可移植的。|1196138|因此，当你用delete替换delete[]没有任何好处，但却冒着大量依赖于未定义行为的风险时，情况就是这样。|1196139|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

There's really no reason to write like that and a serious reason to never do so.

It's true that for types with trivial destructors (like raw pointers in your case) there's no need to know the actual number of elements in the array and so the compiler might decide to map new[] and delete[] onto new and delete to reduce the overhead. If it decides this way you can't stop it without extra steps taken, so this compiler optimization will take place without your notice and will be free.

At the same time someone using your code might wish to overload the global operators new and delete (and new[] and delete[] as well). If that happens you run into big trouble because this is when you may really need the difference between the delete and delete[].

Add to this that this compiler-dependent optimization is unportable.

So this is the case when you get no benefits displacing delete[] with delete but risk big time relying into undefined behaviour.

blocks|key|4722383|text|如果你这样做，你将得到C%2B%2B标准所说的未定义的行为--任何事情都可能发生。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4722384|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you do this, you will get what the C++ Standard calls undefined behaviour - anything could happen.

blocks|key|659264|text|这是一个内存泄漏。delete+[]必须与new+[]匹配。此外，由于table是指向指针数组的第一个元素的指针，因此需要使用delete+[]释放任何数组成员，如果它本身是一个数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|659265|entityMap^0|9|9|L|6|Z|5|1R|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

That is a memory leak. A <code>new []</code> must be matched by a <code>delete []</code>. Further, since <code>table</code> is a pointer to the first element of an array of pointers, any array member, if it's an array by itself will need to be de-allocated using a <code>delete []</code>.

blocks|key|659407|text|这不仅没有好处，而且代码是完全错误的--往好了说，它会泄漏内存，往坏了说，它会使程序崩溃或打开一个难以找到的安全漏洞。您必须始终将new与delete匹配，将new[]与delete[]匹配。一直都是。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|659408|entityMap^0|1T|3|1X|6|27|5|2D|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

Not only is there no benefit, the code is just plain wrong -- at best, it leaks memory, and at worst, it can crash your program or open up a hard-to-find security hole. You must always match <code>new</code> with <code>delete</code> and <code>new[]</code> with <code>delete[]</code>. Always.

blocks|key|4722516|text|这绝对是错误的，因为s+new[]需要与delete[]配对。如果你不这样做，你会得到未定义的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4722517|它可能会工作(部分地)，因为大多数实现都使用new来实现new[]。这种实现的唯一区别是它只会调用一个析构函数(对于第一个元素，而不是所有的析构函数。但避免它，因为它是合法的，而不是+c%2B%2B。|offset|length|style|BOLD|4722518|entityMap^0|0|2J|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

It's definitely wrong as a s new[] needs to be paired with delete[]. If you don't you will get undefined behavior.

It may work (partially), because most implementations use new to implement new[]. The only difference for such an implementation would be that it would only call 1 destructor (for the first element instead of all destructors. But avoid it as it is not legal c++.

blocks|key|3879343|text|理论上，您应该调用delete+[]。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3879344|编辑：以下内容仅适用于Microsoft+Visual+C%2B%2B+(我应该这么说)。|offset|length|style|BOLD|3879345|实际上，在Microsoft+Visual+C%2B%2B中，当数组中的对象没有析构函数时，使用哪个delete并不重要。因为你有一个指针数组，而指针不能有析构函数，所以你应该没问题。|3879346|然而，正如其他人所指出的那样，混合使用C%2B%2B+[]和delete而不使用[]是不正确的。虽然它在这种情况下可以在Visual+C%2B%2B中工作，但代码是不可移植的，并且可能在其他编译器中失败。|3879347|但回到Visual+delete的具体情况，即使您调用C%2B%2B+[]，编译器也会意识到，当它是一个基元类型的数组(如int、char或指针)时，它不需要迭代调用析构函数的数组。在这种情况下，调用delete实际上是有效的，不会破坏任何东西。做正确的事情并调用delete+[]不会更慢，但也不会更快。|3879348|实际上，在MSVC%2B%2B中，当p是指向简单类型的指针或没有析构函数的类型时，delete[]+p会立即调用常规操作符delete(空*p)。|3879349|那些不相信我的人，单步通过这段代码进入CRT代码，用于前两个对delete[]的调用。|3879350|#include+"stdafx.h"
#include+<malloc.h>
#include+<iostream>
using+namespace+std;

class+NoDestructor
{
++++int+m_i;
};

class+WithDestructor
{
public:
++++~WithDestructor()
++++{
++++++++cout+<<+"deleted+one+WithDestructor+at+"+<<+(void+*)+this<<+endl;
++++}
};

int+_tmain(int+argc,+_TCHAR*+argv[])
{
++++int+**p+=+new+int+*[20];
++++delete+[]+p;

++++p+=+(int**)+malloc(80);
++++free(p);

++++NoDestructor+*pa+=+new+NoDestructor[20];
++++delete+[]+pa;

++++WithDestructor+*pb+=+new+WithDestructor[20];
++++delete+[]+pb;

++++return+0;
}|code-block|syntax|javascript|3879351|entityMap^0|0|3|S|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|15|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|16|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|17|8|@]|9|@]|A|$U|V]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

In theory you should call delete []. 

EDIT: The following applies only to Microsoft Visual C++ (I should have said this).

In practice, in Microsoft Visual C++ , it doesn't matter which delete you use when the objects in the array don't have destructors. Since you have an array of pointers, and pointers can't have destructors, you should be OK. 

However, as others have pointed out, it is incorrect C++ to mix new [] and delete without []. Although it may work in Visual C++ in this case, the code is not portable and may fail in other compilers. 

But going back to the specific case of Visual C++, even if you call delete [], the compiler will realize that it doesn't need to iterate through the array calling destructors when it's an array of primitive types like int, char, or pointers. Calling delete in that case actually works and won't break anything. It would not be slower to do the right thing and call delete [], but it won't be faster either.

In fact, in MSVC++, delete[] p immediately calls the regular operator delete(void *p) when p is a pointer to a simple type, or one without destructors.

Those who don't believe me, step through this code into the CRT code for the first two calls to delete[]. 

<pre><code>#include "stdafx.h"
#include &lt;malloc.h&gt;
#include &lt;iostream&gt;
using namespace std;

class NoDestructor
{
 int m_i;
};

class WithDestructor
{
public:
 ~WithDestructor()
 {
 cout &lt;&lt; "deleted one WithDestructor at " &lt;&lt; (void *) this&lt;&lt; endl;
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 int **p = new int *[20];
 delete [] p;

 p = (int**) malloc(80);
 free(p);

 NoDestructor *pa = new NoDestructor[20];
 delete [] pa;

 WithDestructor *pb = new WithDestructor[20];
 delete [] pb;

 return 0;
}
</code></pre>

blocks|key|659359|text|该语句将把数组中所有指针所指向的所有myClass对象留在内存中。它还会将指针数组留在内存中。这是没有用的，因为它只释放了32位的内存，而且操作系统仍然认为你有(大小)的myClasses和指向每个内存的指针。这只是一个程序员没有正确清理自己的例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659360|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

that statement will leave all of the myClass objects that were pointed to by all the pointers in the array hanging around in memory. It also leaves the array of pointers in memory. There is no way that can be helpful, as it only frees up 32 bits of memory, and the OS still thinks you have (size) myClasses and pointers to each in use. This is just an example of a programmer not cleaning up after themself properly.

blocks|key|3879392|text|请参阅第16.11节“如何分配/取消分配事物数组？”在C%2B%2B常见问题解答精简版中，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3879393|http://www.parashift.com/c%2B%2B-faq-lite/freestore-mgmt.html#faq-16.11|offset|length|3879394|他们解释说，在创建数组时必须删除数组。|3879395|数组元素指向的myClass实例也应该在创建它们的位置被删除。|3879396|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/freestore-mgmt.html#faq-16.11^0|0|0|1V|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Check with the section [16.11] "How do I allocate / unallocate an array of things?" and beyond in C++ FAQ Lite,

<a href="http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.11" rel="nofollow noreferrer">http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.11</a>

They explain that the array delete is a must when an array is created.

The instanced of myClass pointed to by the elements of your array should also be deleted where they are created.

I came across this kind of code once in a while - I suspect the creator is/was afraid that table delete would iterate over the table and "cost performance" (which imho will not be done either way)... is there any real benefit one might get/consider/imagine from not using the the table delete here?

<pre><code>myClass** table = new myClass* [size];
... //some code that does not reallocate or change the value of the table pointer ;)
delete table; // no [] intentionally
</code></pre>

Why would you write something like this? (intentionally not using delete [] on an array)

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我偶尔会遇到这样的代码-我怀疑创建者害怕表删除会在表上迭代和“性价比”(这两种方式都不会实现)……在这里不使用表delete有什么实际的好处吗？myClass** table = new myClass* [size];... //some code that does not reallocate or change the value of the table pointer ;)delete

问你为什么要写这样的东西？(有意不对数组使用delete [] )
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你为什么要写这样的东西？(有意不对数组使用delete [] )EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你为什么要写这样的东西？(有意不对数组使用delete [] )
EN