blocks|key|2475597|text|delete运算符调用对象的析构函数并释放先前分配给对象的内存。它不会影响指向已删除对象的指针变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2475598|因此，当取消引用指向已销毁对象的指针时，您会遇到麻烦。|2475599|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

delete operator calls the destructor of the object and deallocates the memory previously allocated to the object. It doesn't affect the pointer variable that points to the deleted object. 

So when dereferencing a pointer pointing to a destroyed object, you'll get trouble.

blocks|key|754020|text|调用delete会将内存区标记为空闲。它将不需要重置其旧值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|754021|建议您在调用delete后将指针设置为0：|754022|delete+pTest;
pTest+=+0;|code-block|syntax|javascript|754023|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Calling delete will mark the memory area as free. It won't necessary reset its old value.

You are advised to set your pointer to 0, after calling delete:

<pre><code>delete pTest;
pTest = 0;
</code></pre>

blocks|key|1502631|text|是时候学习什么是未定义的行为了。:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1502632|在C%2B%2B中，当你做一些非法的/无意义的/坏的/等等的事情时，标准通常会说“它会导致未定义的行为”。这意味着从这一点开始，你的程序的状态是完全不能保证的，任何事情都可能发生。|1502633|在执行最后一次*(pTest)时，您会得到未定义的行为。这是因为pTest没有指向有效的对象，并且取消引用这样的指针是未定义的。所以你所看到的是完全允许的:未定义的输出。|offset|length|style|CODE|1502634|你所做的只是说“我已经完成了这个分配”。一旦你这样说了，你就不应该(实际上也不能)检查或关心那个记忆了。取消分配一些东西，然后尝试使用它，这在概念上甚至没有意义；你说过你已经完成了！|1502635|不过，您的输出在某种程度上是可以预测的:很可能，您的操作系统只是简单地说“好的，谢谢您的内存”，仅此而已。它实际上没有理由“重置”内存，或者做任何特殊的事情。当没有人(包括您自己的程序)不使用它时，这确实是浪费时间。|1502636|但请记住，此输出是完全未定义的。不要试图使用不存在的对象。也许更好的测试应该是：|1502637|#include+<iostream>

struct+foo
{
++++~foo()
++++{
++++++++std::cout+<<+"foo+is+gone+:("+<<+std::endl;
++++}
};

int+main(void)
{
++++foo*+f+=+new+foo();
++++delete+f;+//+you'll+see+that+the+object+is+destroyed.
}|code-block|syntax|javascript|1502638|尽管你看起来是想看看记忆本身会发生什么。只需记住，清除内存然后尝试使用它是没有意义的，所以答案是:谁知道呢。这取决于您的特定平台，而C%2B%2B并不关心。|1502639|entityMap^0|0|0|7|8|W|5|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|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@$F|11|G|12|H|I]|$F|13|G|14|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|16|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|17|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|18|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

It's time to learn what undefined behavior is. :)

In C++, when you do something illegal/nonsensical/bad/etc. the standard often says that "it leads to undefined behavior." This means that from that point forward, the state of your program is completely non-guaranteed, and anything could happen.

At the point where you do your last <code>*(pTest)</code>, you get undefined behavior. This is because <code>pTest</code> does not point to a valid object, and dereferencing such a pointer is undefined. So what you're seeing is totally allowed: undefined output.

All you've done is said "I'm finished with this allocation." Once you've said that, you shouldn't (and indeed, cannot) inspect or care about that memory any longer. It doesn't even make conceptual sense to deallocate something then try to use it; you've said you were done!

Your output is somewhat predictable though: likely, your OS simply says "okay, thanks for the memory" and that's it. It has no reason to actually "reset" the memory, or do anything special. That would indeed be a waste of time, when nobody (including your own program) is not using it.

But remember, this output is completely undefined. Don't try to use objects that don't exist. Perhaps a better test would have been:

<pre><code>#include &lt;iostream&gt;

struct foo
{
 ~foo()
 {
 std::cout &lt;&lt; "foo is gone :(" &lt;&lt; std::endl;
 }
};

int main(void)
{
 foo* f = new foo();
 delete f; // you'll see that the object is destroyed.
}
</code></pre>

Although it seems you were looking to see what happens with the memory itself. Just remember that it makes no sense to get rid of memory then try to use it, so the answer is: who knows. It's up to your specific platform, which C++ doesn't care about.

blocks|key|2475757|text|它可以引用任何映射内存。或者可能是未映射的内存，这取决于您的程序已经执行了多长时间，内存分配的细节，以及库是否稍后将内存返回给操作系统……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2475758|如果delete实际上清除了所有正在被删除的内存，程序将花费更长的时间运行，因为它们将浪费大量时间来清理内存，这些内存迟早会被覆盖。它可能对调试很好，但在生产使用中，实际清理内存内容的需求并不多。(当然，加密密钥是一个很好的例外；在调用delete或free之前清除它们是一个好主意。)|offset|length|style|CODE|2475759|entityMap^0|0|2|6|3A|6|3H|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]|$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|I|$]]

It could have referred to any piece of mapped memory. Or maybe unmapped memory, depending upon how long your program has been executing, details of memory allocations, and if the libraries are returning memory to the OS later on...

If <code>delete</code> actually cleared all the memory that is being deleted, programs would spend a significantly longer time running, because they'd waste a lot of time scrubbing memory that will probably be overwritten sooner or later anyway. It might be good for debugging, but in production use, there's just not much call for actually scrubbing memory contents. (Crypto keys are a good exception, of course; scrubbing those before calling <code>delete</code> or <code>free</code> is a good idea.)

blocks|key|3883594|text|销毁数据意味着什么？我想它可以将其归零，但为什么要麻烦呢？当我们从环境中获取它时，它被认为是脏的，那么为什么在我们返回它之前清理它呢？我们不在乎里面有什么，因为我们放弃了阅读它的权利。至于为什么delete不清零指针本身：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3883595|http://www2.research.att.com/~bs/bs_faq2.html#delete-zero|offset|length|3883596|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1L|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

What would destroying the data mean? I suppose it could zero it out, but why bother? It's assumed dirty when we get it from the environment, so why clean it before we return it? We don't care what's in it, because we are relinquishing our right to read it. And as to why delete doesn't zero out the pointer itself:

<a href="http://www2.research.att.com/~bs/bs_faq2.html#delete-zero" rel="nofollow noreferrer">http://www2.research.att.com/~bs/bs_faq2.html#delete-zero</a>

blocks|key|3883646|text|取消引用指向已释放内存的指针是未定义的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3883647|很多时候它会正常工作，因为new提供的内存通常是分配器管理的更大的已分配内存块的一部分。当你调用delete时，它会调用相关的析构函数，并将内存标记为空闲，这通常意味着“准备好重用”。因此，查看内存，您会发现在调用delete之前存在相同的数据，或者如果在new调用之后重新分配了该内存块，则会发现一些其他数据。|offset|length|style|CODE|3883648|请注意，没有什么可以禁止new/delete分配器作为OS虚拟内存函数的瘦包装器工作，因此，当相对于页面的所有已分配块都已释放时，整个页面都会被释放，任何访问它的尝试都会导致地址冲突。|3883649|TL，DR版本:不要尊重指向释放内存的指针:它有时可能会工作，有时会返回垃圾，有时会触发访问冲突。|3883650|如果你犯了这种错误，一个好办法是在删除它们所指向的内存后将指针设置为NULL+:如果您的代码试图取消引用NULL指针，在几乎任何系统上这都会导致应用程序崩溃，所以这样的错误不会被忽略。|3883651|entityMap^0|0|D|3|1C|6|2Z|6|3K|3|0|C|3|G|6|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|14|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|15|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|O|$]]

Dereferencing a pointer that points to deallocated memory is undefined behavior.

Many times it will just work, because the memory provided by <code>new</code> is usually part of a bigger chunk of allocated memory that the allocator manages. When you call <code>delete</code>, it will call the relevant destructors and mark the memory as free, which usually means "ready for reuse". So, looking in that memory you'll find the same data that was there before the call to <code>delete</code>, or some other data if that chunk of memory has been reassigned after a <code>new</code> call.

Note that nothing forbids that the <code>new</code>/<code>delete</code> allocator works as a thin wrapper around the OS virtual memory functions, so when all the allocated blocks relative to a page has been deallocated, the whole page is freed and any attempt to access it results in an address violation.

TL,DR version: don't deference pointers which point to deallocated memory: it may work sometimes, sometimes will give you back garbage, sometimes it will trigger an access violation.

A good way to notice immediately if you're doing this kind of mistake is to set your pointers to NULL after deleting the memory they point to: if your code tries to dereference a NULL pointer, on almost any system this will make the application crash, so faults like these won't go unnoticed.

blocks|key|2475902|text|这只是一个简单的例子来说明可能发生的事情，以及一些人提到的未定义的行为意味着什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2475903|如果我们在打印之前添加两行额外的代码：|2475904|delete+pTest;

int+*foo+=+new+int;
*foo+=+42;

cout+<<+*pTest+<<+endl;|code-block|syntax|javascript|2475905|pTest的打印值很可能是3，就像您的例子一样。但是，打印值也可以是42。当pTest指针被删除时，它的内存被释放。正因为如此，foo指针有可能指向内存中pTest在被删除之前所指向的相同位置。|2475906|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just a simple example to illustrate what might happen, and what the undefined
behaviour that some people mentioned means.

If we add two extra lines of code before the print:

<pre><code>delete pTest;

int *foo = new int;
*foo = 42;

cout &lt;&lt; *pTest &lt;&lt; endl;
</code></pre>

The printed value of pTest could very well be 3, as it was in your case.
However, the printed value could also be 42. As the pTest pointer was deleted,
its memory was freed. Because of this, it is possible that the foo pointer will
point to the same location in memory that pTest used to point to before it was
 deleted.

blocks|key|3883722|text|答案是性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3883723|用无效值(0xCCCCCCCC、0xDEADDEAD等)填充所有释放的内存是一个很好的调试辅助工具。捕获使用指向已释放内存的陈旧指针的尝试。|offset|length|style|CODE|3883724|但是修改释放的内存会占用CPU时间，因此出于性能原因，操作系统只会将释放的内存块添加到它的“空闲”列表中，并保持内容不变。|3883725|entityMap^0|0|5|A|G|A|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

The answer is performance.

It's a great debug aid to fill all freed memory with an invalid value (<code>0xCCCCCCCC</code>, <code>0xDEADDEAD</code>, etc.) to catch attempts to use stale pointers to already-freed memory. 

But modifying a freed memory costs CPU time, so for performance reasons, the OS will just add the freed memory block to its "free" list, and leave the contents intact.

blocks|key|2476026|text|为指针调用delete将其指向的内存块标记为“释放内存”。它不会立即销毁内存中的项目。“item”只有在进程返回后才会被销毁，因为“delete”被用于指向该内存块的指针。如果没有使用'delete‘，它将永远保留在那里，从而导致内存泄漏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2476027|要解决您的问题，只需：|2476028|delete+pTest;
pTest=NULL;|code-block|syntax|javascript|2476029|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Calling delete for a pointer marks the memory block pointed by it to 'free memory'. It doesn't destroy the items in the memory right away. The 'items' get destroyed only after the process has returned given that 'delete' was used for the pointer pointing to that memory block. In case 'delete' isn't used, it stays there forever resulting in a memory leak.
To solve your problem, just:
<pre><code>delete pTest;
pTest=NULL;
</code></pre>

I'm playing a little with memory dynamic allocation, but I don't get a point. When allocating some memory with the <code>new</code> statement, I'm supposed to be able to destroy the memory the pointer points to using <code>delete</code>.

But when I try, this <code>delete</code> command doesn't seem to work since the space the pointer is pointing at doesn't seem to have been emptied.

Let's take this truly basic piece of code as an example:

<pre><code>#include &lt;iostream&gt; 

using namespace std;

int main() 
{ 
 //I create a pointer-to-integer pTest, make it point to some new space, 
 // and fulfill this free space with a number; 
 int* pTest; 
 pTest = new int; 
 *(pTest) = 3; 
 cout &lt;&lt; *(pTest) &lt;&lt; endl; 

 // things are working well so far. Let's destroy this
 // dynamically allocated space!
 delete pTest;

 //OK, now I guess the data pTest pointed to has been destroyed 
 cout &lt;&lt; *(pTest) &lt;&lt; endl; // Oh... Well, I was mistaking. 

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

Any clue ?

Why doesn't delete destroy anything?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我玩了一点内存动态分配的游戏，但我不明白。在使用new语句分配一些内存时，我应该能够使用delete销毁指针所指向的内存。但是当我尝试时，这个delete命令似乎不起作用，因为指针所指向的空间似乎没有被清空。让我们以这段真正基本的代码为例：#include <iostream> using namespace std...

问为什么delete不销毁任何东西？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么delete不销毁任何东西？EN