blocks|key|780841|text|一旦你删除了b，你就没有权限改写它的位置了。但是您通常可以做到这一点；并且您将看到程序员使用memset实现这一点的代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|780842|780843|不过，被认可的方法是直接调用析构函数，然后覆盖内存(比如用memset)，然后在对象上调用delete。这确实要求析构函数非常智能，因为delete将调用析构函数。所以析构函数必须意识到整个对象只是0的对象，并且不做任何事情：|780844|b->~B();
memset(b,+0,+sizeof(b));
delete+b;|code-block|syntax|javascript|780845|entityMap^0|6|1|1A|6|0|0|T|6|19|6|1W|6|2R|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]|$1|G|3|H|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|I|3|J|5|K|7|14|8|@]|D|@]|E|$L|M]]|$1|N|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|O|$]]

Once you've deleted <code>b</code> you don't really have permission to write over where it was. But you usually can get away with doing just that; and you'll see code where programmers use <code>memset</code> for this.

<hr>

The approved way to do this, though, would be to call the destructor directly, then write over the memory (with, say, <code>memset</code>) and then call <code>delete</code> on the object. This does require your destructor to be pretty smart because <code>delete</code> is going to call the destructor. So the destructor must realize that the whole object is nothing but <code>0</code>'s and not do anything:

<pre><code>b-&gt;~B();
memset(b, 0, sizeof(b));
delete b;
</code></pre>

blocks|key|1256726|text|您可能应该覆盖delete操作符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1256727|给定类B的示例：|1256728|class+B
{
public:

++//+your+code
++...

++//+override+delete
++void+operator+delete(void+*+p,+size_t+s)
++{
++++::memset(p,+0,+s);
++++::operator+delete(p,+s);
++}
};|code-block|syntax|javascript|1256729|编辑：感谢litb指出这一点。|BOLD|1256730|entityMap^0|7|6|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|V|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|W|8|@$9|X|A|Y|B|O]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|Q|$]]

You probably should override the <code>delete</code> operator.

Example for the given class B:

<pre><code>class B
{
public:

 // your code
 ...

 // override delete
 void operator delete(void * p, size_t s)
 {
 ::memset(p, 0, s);
 ::operator delete(p, s);
 }
};
</code></pre>

EDIT: Thanks litb for pointing this out.

blocks|key|4845200|text|另一位发帖者建议：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4845201|+delete+b;
+memset(b,0,sizeof(B));|code-block|syntax|javascript|4845202|请不要这样做！对返回到内存管理器的地址空间的写入未定义！|4845203|即使你的编译器和库现在让你逃脱惩罚，它也是糟糕的糟糕的。库或平台中的更改，甚至编译器中的更新都会咬你的屁股。|4845204|想一想竞争条件，你删除b，然后其他线程进行分配，b处的内存被释放，然后你调用memset！邦，你死定了。|4845205|如果你必须清除内存(谁会关心)，在调用delete之前将其清零。|4845206|+memset(b,0,sizeof(B));
+delete+b;|4845207|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Another poster suggested:

<pre><code> delete b;
 memset(b,0,sizeof(B));
</code></pre>

Please don't do this!!! Writes to address space that is returned to the memory manager are UNDEFINED!!!!

Even if your compiler and library let you get away with it now, it is bad bad bad. A change in library or platform, or even an update in the compiler will bite you in the ass.

Think of a race condition where you delete b, then some other thread makes an allocation, the memory at b is given out, and then you call memset! Bang, you're dead.

If you must clear the memory (which who cares) zero it out before calling delete.

<pre><code> memset(b,0,sizeof(B));
 delete b;
</code></pre>

blocks|key|4845217|text|如果可以(http://www.parashift.com/c%2B%2B-faq-lite/dtors.html#faq-11.10)，请使用“新”的位置，并将手动调用对象析构函数后给出的块清零。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4845218|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/dtors.html#faq-11.10^0|5|1M|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]]]]

Use placement "new" if you can (<a href="http://www.parashift.com/c++-faq-lite/dtors.html#faq-11.10" rel="nofollow noreferrer">http://www.parashift.com/c++-faq-lite/dtors.html#faq-11.10</a>)
and zero out the chunk you gave after calling the object destructor manually.

blocks|key|781056|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|781057|+accessBMemberVariable应该核心转储，但它没有|blockquote|781058|781059|781060|不，为什么要这样呢？很有可能b曾经占用的内存现在归CRT所有了，你的应用程序拥有的CRT。CRT可能会选择不将内存释放回操作系统。核心转储只有在访问不属于应用程序的内存时才会发生。|781061|将b占用的内存清零可能对您没有任何好处，这取决于A具有地址的变量的类型。|781062|我的建议是在堆栈上分配B，这应该会产生烟花…但话又说回来，并不完全是你所期望的方式...|781063|因此，如果你真的想要一个核心转储，你应该使用操作系统函数来分配内存并释放它：|781064|char+*buf+=+OS_Alloc(sizeof(B));
B+*b+=+new(buf)+B();
a->someBMember+=+&b->myMember;
b->~B();
OS_Free(buf);
a->accessBMemberVariable();|code-block|syntax|javascript|781065|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|U|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|V|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|W|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|X|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|Y|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|Z|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|10|7|@]|8|@]|9|$]]|$1|L|3|M|4|5|6|11|7|@]|8|@]|9|$]]|$1|N|3|O|4|P|6|12|7|@]|8|@]|9|$Q|R]]|$1|S|3|-4|4|5|6|13|7|@]|8|@]|9|$]]]|T|$]]

<blockquote>
 accessBMemberVariable should coredump, but it doesn't
</blockquote>

Nah, why should it? It's quite possible that the memory that b used to occupy is now owned by the CRT, the CRT that your application owns. The CRT may opt to not release memory back to the OS. Core dumps will only happen if you access memory not owned by your application.

Zeroing out the memory occupied by b may not do you any good depending on the type of variable that A has the address of.

My advice would be to allocate B on the stack, that should bring out the fireworks... but then again, not quite in the way you'd expect...

So if you really want a core dump you should use the OS functions to allocate memory and free it:

<pre><code>char *buf = OS_Alloc(sizeof(B));
B *b = new(buf) B();
a-&gt;someBMember = &amp;b-&gt;myMember;
b-&gt;~B();
OS_Free(buf);
a-&gt;accessBMemberVariable();
</code></pre>

blocks|key|1256846|text|在您的示例中，您可以这样写|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1256847|'A->accessBMemberVariable‘这是拼写错误吗？它不应该是'a->accessBMemberVariable‘吗？|1256848|假设这是一个打字错误(否则整个设计看起来有点奇怪)。|1256849|如果你想验证'a‘是否被正确删除，最好改变你处理分配的方式，使用auto_ptr。这样，您将确保内容被正确删除：|1256850|auto_ptr<A>+a(+new+A+);
{
++auto_ptr+b(+new+B(a)+);+//+B+takes+ownership+of+'a',+delete+at+scope+exit
}
a->accessBMemberVariable();+//+shouldn't+do+to+well.|code-block|syntax|javascript|1256851|以及B的构造函数，其形式为|1256852|B(+auto_ptr<A>&+a+)+:+m_a(a)+{;}|1256853|哪里|1256854|auto_ptr<A>+m_a|1256855|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

In your example you write

'A->accessBMemberVariable' is this a typo? shouldn't it be 'a->accessBMemberVariable' ?

Assuming it is a typo (otherwise the whole design seems a bit weird).

If you want to verify that 'a' is deleted properly it probably be better to instead change the way you handle the allocation and use auto_ptr's instead. That way you will be sure things are deleted properly:

<pre><code>auto_ptr&lt;A&gt; a( new A );
{
 auto_ptr&lt;B&gt; b( new B(a) ); // B takes ownership of 'a', delete at scope exit
}
a-&gt;accessBMemberVariable(); // shouldn't do to well.
</code></pre>

and a constructor for B in the form of 

<pre><code>B( auto_ptr&lt;A&gt;&amp; a ) : m_a(a) {;}
</code></pre>

where 

<pre><code>auto_ptr&lt;A&gt; m_a
</code></pre>

blocks|key|781158|text|在您的环境中使用调试malloc/new功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|781159|在MSVC上，链接到调试运行时库。在FreeBSD上，根据需要将MALLOC_OPTIONS设置为具有'Z‘或'J’标志。在其他平台上，请阅读文档或将其替换为具有调试支持的适当分配器。|781160|在删除后调用memset()在很多层面上都是不好的。|781161|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Use the debugging malloc/new features in your environment.

On MSVC, link with the debug runtime libraries. On FreeBSD, set MALLOC_OPTIONS to have the 'Z' or 'J' flags, as appropriate. On other platforms, read the documentation or substitute in an appropriate allocator with debugging support.

Calling memset() after deletion is just bad on so many levels.

Is it possible to zero out the memory of deleted objects in C++? I want to do this to reproduce a coredump in unit test:

<pre><code>//Some member variable of object-b is passed-by-pointer to object-a
//When object-b is deleted, that member variable is also deleted
//In my unit test code, I want to reproduce this
//even if I explicitly call delete on object-b
//accessBMemberVariable should coredump, but it doesn't
//I'm assuming even though object-b is deleted, it's still intact in memory
A *a = new A();
{
 B *b = new B(a);
 delete b;
}
a-&gt;accessBMemberVariable();
</code></pre>

how do clean up deleted objects in C++

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

是否有可能将C++中已删除对象的内存清零？我想这样做是为了在单元测试中重现一个核心转储：//Some member variable of object-b is passed-by-pointer to object-a//When object-b is deleted, that member variable ...

问如何在C++中清理已删除的对象
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C++中清理已删除的对象EN