blocks|key|230559|text|尽可能地使用RAII成语|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|230560|在适当的地方使用智能指针，例如std::auto_ptr。(不要在任何标准集合中使用auto_prt，因为它不会像您想象的那样工作)|230561|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization^0|6|4|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Use the <a href="http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization" rel="nofollow noreferrer">RAII</a> idiom everywhere you can

Use smart pointers, e.g. std::auto_ptr where appropriate. (don't use auto_prt in any of the standard collections as it won't work as you think it will)

blocks|key|230856|text|尽可能避免动态创建对象。来自Java和其他类似语言的程序员通常编写如下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230857|string+*+s+=+new+string(+"hello+world"+);|code-block|syntax|javascript|230858|当他们应该写下：|230859|string+s+=+"hello+world";|230860|类似地，当它们应该创建值集合时，它们会创建指针集合。例如，如果您有一个如下所示的类：|230861|class+Person+{
+++public:
++++++Person(+const+string+&+name+)+:+mName(+name+)+{}
++++++...
+++private:
++++++string+mName;
};|230862|而不是像这样编写代码：|230863|vector+<Person+*>+vp;|230864|或者甚至是：|230865|vector+<shared_ptr+<Person>+>+vp;|230866|取而代之的是：|230867|vector+<Person>+vp;|230868|您可以很容易地添加到这样的向量中：|230869|vp.push_back(+Person(+"neil+butterworth"+)+);|230870|并且为您管理Person和vector的所有内存。当然，如果你需要一个多态类型的集合，你应该使用(智能)指针|230871|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|1M|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

Avoid creating objects dynamically wherever possible. Programmers coming from Java and other similar languages often write stuff like:

<pre><code>string * s = new string( "hello world" );
</code></pre>

when they should have written:

<pre><code>string s = "hello world";
</code></pre>

Similarly, they create collections of pointers when they should create collections of values. For example, if you have a class like this:

<pre><code>class Person {
 public:
 Person( const string &amp; name ) : mName( name ) {}
 ...
 private:
 string mName;
};
</code></pre>

Rather than writing code like:

<pre><code>vector &lt;Person *&gt; vp;
</code></pre>

or even:

<pre><code>vector &lt;shared_ptr &lt;Person&gt; &gt; vp;
</code></pre>

instead use values:

<pre><code>vector &lt;Person&gt; vp;
</code></pre>

You can easily add to such a vector:

<pre><code>vp.push_back( Person( "neil butterworth" ) );
</code></pre>

and all the memory for both Person and the vector is managed for you. Of course, if you need a collection of polymorphic types, you should use (smart) pointers

blocks|key|1333998|text|Use+Smart+Pointers|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1333999|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/sp_techniques.html^0|0|I|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]]]]

<a href="http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/sp_techniques.html" rel="nofollow noreferrer">Use Smart Pointers</a>

blocks|key|230729|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230730|使用RAII|ordered-list-item|230731|在每个类中隐藏默认复制|230732|，operator=()，除非a)您的类很普通并且只使用本机类型，并且您知道它将始终如此b)您显式定义了您自己的|230733|在RAII上，这个想法是让删除自动发生，如果你发现自己在想“我刚刚调用了new，我需要记住在某个地方调用delete”，那么你就做错了什么。删除应该是a)自动的，或者b)放在一个dtor中(哪个dtor应该是显而易见的)。|230734|2)隐藏默认值。识别恶意的默认拷贝ctor等可能是一场噩梦，最简单的事情是通过隐藏它们来避免它们。如果你有一个通用的“根”对象，所有的东西都继承自它(无论如何对于调试/分析都很方便)，那么当某个东西试图分配/复制一个继承类时，编译器会断然拒绝，因为ctor的etc在基类上不可用。|230735|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|N|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|O|7|@]|8|@]|9|$]]|$1|D|3|E|4|C|6|P|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|Q|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|R|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|S|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|T|7|@]|8|@]|9|$]]]|M|$]]

<ol>
<li>Use RAII</li>
<li>Hide default copy ctors, operator=()
 in EVERY CLASS,
unless a) your class is trivial and
only uses native types and YOU KNOW
IT ALWAYS WILL BE SO b) you
explicitly define your own</li>
</ol>

On 1) RAII, the idea is to have deletes happen automatically, if you find yourself thinking "I just called new, I'll need to remember to call delete somewhere" then you're doing something wrong. The delete should either be a) automatic or b) be put in a dtor (and which dtor should be obvious).

On 2) Hiding defaults. Identifying rogue default copy ctors etc can be a nightmare, the easiest thing is to avoid them by hiding them. If you have a generic "root" object that everything inherits from (can be handy for debugging / profiling anyway) hide the defaults here, then when an something tries to assign / copy an inheriting class the compiler barfs because the ctor's etc aren't available on the base class.

blocks|key|1530412|text|通过使用STL容器存储数据，最大限度地减少对new的调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1530413|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|$]]

Minimize the calls to new by using the STL containers for storing your data.

blocks|key|230788|text|我支持Glen和jalf关于RAII的一切机会。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230789|我想你的目标应该是写出完全无删除的代码。唯一显式的“删除”应该在你的智能指针类实现中。如果你发现自己想要写一个"delete"，那就去找一个合适的智能指针类型。如果没有一个“行业标准”(boost等)适合你，并且你发现自己想要写一些奇怪的新的，那么你的体系结构很有可能被打破了，或者至少在未来会有维护困难。|230790|我一直认为显式的"delete“是内存管理，就像"goto”是流控制。有关这方面的更多信息，请访问this+answer。|offset|length|230791|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/959621/c-idiom-to-avoid-memory-leaks/959708#959708^0|0|0|1D|B|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I'm with Glen and jalf regarding RAII at every opportunity.

IMHO you should aim to write completely delete-free code. The only explicit "delete"s should be in your smart pointer class implementations. If you find yourself wanting to write a "delete", go and find an appropriate smart pointer type instead. If none of the "industry standard" ones (boost's etc) fit and you find yourself wanting to write some bizzare new one, chances are your architecture is broken or at the least there will be maintenance difficulties in future.

I've long held that explicit "delete" is to memory management what "goto" is to flow control. More on this in <a href="https://stackoverflow.com/questions/959621/c-idiom-to-avoid-memory-leaks/959708#959708">this answer</a>.

blocks|key|230599|text|当我需要在堆上创建一个新对象时，我总是使用std::auto_ptr。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|230600|std::auto_ptr<Foo>+CreateFoo()
{
+++return+std::auto_ptr<Foo>(new+Foo());
}|code-block|syntax|javascript|230601|即使你打电话给|230602|CreateFoo()|230603|不会漏水的|230604|entityMap^0|L|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

I always use <code>std::auto_ptr</code> when I need to create a new object on the heap.

<pre><code>std::auto_ptr&lt;Foo&gt; CreateFoo()
{
 return std::auto_ptr&lt;Foo&gt;(new Foo());
}
</code></pre>

Even if you call 

<pre><code>CreateFoo()
</code></pre>

it won't leak

blocks|key|1334239|text|基本步骤有两个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1334240|首先，要知道每一个新的东西都需要删除。因此，当您使用new运算符时，请提高您对该对象将执行的操作、如何使用它以及如何管理其生命周期的认识。|1334241|其次，确保您永远不会覆盖指针。您可以使用智能指针类而不是原始指针来完成此操作，但如果您确实要确保绝对不要将其与隐式转换一起使用。(一个示例:使用MSXML库，我创建了一个CCOMPtr智能指针来保存节点，以获取您调用的get_Node方法的节点，传入智能指针的地址-它有一个返回底层指针类型的转换操作符。不幸的是，这意味着如果智能指针已经保存了数据，该成员数据将被覆盖，从而泄漏前一个节点)。|1334242|我认为这两种情况都是内存泄漏的时候。如果你只直接使用智能指针--决不允许暴露它的内部数据，你就可以安全地避免后一种问题。如果你将所有使用new和delete的代码包装在一个类中(例如使用RAII)，那么你也可以很安全地避免使用前者。|1334243|如果执行上述操作，则可以很容易地避免C%2B%2B中的内存泄漏。|1334244|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|$]]

The basic steps are twofold:

Firstly, be aware that every new requires a delete. So, when you use the new operator, up your awareness of what that object will be doing, how it will be used, and how its lifetime will be managed. 

Secondly, make sure that you never overwrite a pointer. You can do this using a smart pointer class instead of raw pointers, but if you do make absolutely sure you never use it with implicit conversion. (an example: using MSXML library, I created a CCOMPtr smart pointer to hold nodes, to get a node you call the get_Node method, passing in the address of the smart pointer - which had a conversion operator that returned the underlying pointer type. Unfortunately, this meant that if the smart pointer already held data, that member data would be overwritten, leaking the previous node).

I think those 2 cases are the times when you might leak memory. If you only use the smart pointer directly - never allowing its internal data to be exposed, you're safe from the latter issue. If you wrap all your code that uses new and delete in a class (ie using RAII) then you're pretty safe from the former too.

Avoiding memory leaks in C++ is very easy if you do the above.

blocks|key|4550784|text|两条简单的经验法则：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4550785|4550786|从不显式调用delete+(即在RAII类之外)。每次内存分配都应该由在destructor.|unordered-list-item|offset|length|style|CODE|4550787|Almost中调用delete的RAII类负责，千万不要显式调用new。如果这样做，则应立即将生成的指针包装在智能指针中，该指针将获得分配的所有权，并按上述方式工作。|4550788|4550789|在您自己的RAII类中，有两个常见的陷阱：|4550790|4550791|无法正确处理复制:如果对象被复制，谁将获得内存的所有权？他们会创建新的分配吗？你同时实现复制构造函数和赋值运算符吗？后者是否处理self+assignment?|4550792|Failure以考虑异常安全性。如果在操作过程中抛出异常(例如，赋值)，会发生什么？对象是否恢复到一致状态？(无论发生什么，它都应该这样做)它会回滚到操作前的状态吗？(如果可能的话，它应该这样做)例如，在push_back期间，std::vector必须处理这个问题。这可能会导致向量调整大小，这意味着1)可能抛出的内存分配，以及2)必须复制所有现有元素，每个元素都可能抛出。像std::sort这样的算法也必须处理它。它必须调用用户提供的比较器，这可能也会抛出！如果发生这种情况，序列是否处于有效状态？临时对象是否被彻底析构？|4550793|4550794|如果您在您的RAII类中处理上述两种情况，它们几乎不可能泄漏内存。如果您使用RAII类包装所有资源分配(内存分配、文件句柄、数据库连接以及必须获取和释放的任何其他类型的资源)，那么您的应用程序就不会泄漏内存。|4550795|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Resource%255FAcquisition%255FIs%255FInitialization^0|0|0|6|6|0|W|3|G|4|0|0|0|0|0|0|2U|9|36|B|59|9|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|16|8|@$F|17|G|18|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|19|8|@$F|1A|G|1B|H|I]]|9|@$F|1C|G|1D|1|1E]]|A|$]]|$1|L|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|P|3|Q|5|E|7|1I|8|@]|9|@]|A|$]]|$1|R|3|S|5|E|7|1J|8|@$F|1K|G|1L|H|I]|$F|1M|G|1N|H|I]|$F|1O|G|1P|H|I]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1R|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

Two simple rules of thumb:

<ul>
<li>Never call <code>delete</code> explicitly (outside a RAII class, that is). Every memory allocation should be the responsibility of a <a href="http://en.wikipedia.org/wiki/Resource%5FAcquisition%5FIs%5FInitialization" rel="nofollow noreferrer">RAII</a> class which calls delete in the destructor.</li>
<li>Almost never call <code>new</code> explicitly. If you do, you should immediately wrap the resulting pointer in a smart pointer, which takes ownership of the allocation, and works as above.</li>
</ul>

In your own RAII classes, two common pitfalls are:

<ul>
<li>Failure to handle copying correctly: Who takes ownership of the memory if the object is copied? Do they create a new allocation? Do you implement both copy constructor and assignment operator? Does the latter handle self assignment?</li>
<li>Failure to consider exception safety. What happens if an exception is thrown during an operation (an assignment, for example)? Does the object revert to a consistent state? (it should always do this, no matter what) Does it roll back to the state it had before the operation? (it should do this when possible) <code>std::vector</code> has to handle this, during <code>push_back</code> for example. It might cause the vector to resize, which means 1) a memory allocation which may throw, and 2) all the existing elements have to be copied, each of which may throw. An algorithm like <code>std::sort</code> has to deal with it too. It has to call a user-supplied comparer, which could potentially throw too! if that happens, is the sequence left in a valid state? Are temporary objects destructed cleanly?</li>
</ul>

If you handle the above two cases in your RAII classes, it is pretty much impossible for them to leak memory.
And if you use RAII classes to wrap all resource allocations (memory allocations, file handles, database connections and any other type of resource that has to be acquired and released), then your application can not leak memory.

blocks|key|4550524|text|确保由你的应用程序创建的共享内存被释放，如果没有人再使用它，清理内存映射文件...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4550525|基本上，要确保清理应用程序直接或间接创建的任何类型的资源。文件描述符只是应用程序在运行时可能使用的一种资源类型。|4550526|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|$]]

Make sure shared memory created by your application is freed if nobody's using it anymore, clean up memory mapped files...

Basically, make sure you clean up any type of resource your application directly or indirectly creates. File descriptors are only one type of resource your application may use during runtime.

blocks|key|1530362|text|如果在代码中为数据结构递归地创建任何树或图，可能会消耗掉所有的内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1530363|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 make any tree or graph recursively in your code for your data structure maybe eat all of your memory.

blocks|key|1334153|text|有一些静态代码分析工具可以做这类事情；wikipedia是一个很好的起点。基本上，除了小心和选择正确的容器之外，您不能保证您编写的代码-因此需要valgrind和gdb等工具。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1334154|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis^0|J|9|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]]]]

There are static code analysis tools available that do this sort of thing; <a href="http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis" rel="nofollow noreferrer">wikipedia</a> is a good place to start looking. Basically, outside of being careful and choosing the correct containers you can not make guarantees about the code you write - hence the need for tools such as valgrind and gdb.

blocks|key|1334396|text|将valgrind单元和系统测试合并到开发周期的早期阶段，并一致地使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1334397|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|$]]

Incorporate valgrind unit and system testing early in your development cycle and use it consistantly.

Running valgrind or purify would be the next steps 
But while while writing the code itself how do you ensure that it will not cause any memory leaks?
You can ensure following things:-
1: Number of new equal to delete 
2: Opened File descriptor is closed or not 

Is there any thing else?

How do ensure that while writing C++ code itself it will not cause any memory leaks?

33 天实现自己的 AI 进化论？发文瓜分机械键盘、耳机等万元奖池！点击参加活动：<a href="https://cloud.tencent.com/developer/article/2503022" target="_blank">https://cloud.tencent.com/developer/article/2503022</a> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/01543e0407db10898a7ee9f420794432.jpg"/>

技术创作特训营有奖征文

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

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

腾讯云数据库专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云AI代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

文章&问答评论现已支持表情

运行valgrind或purify将是下一步，但是在编写代码本身的同时，您如何确保它不会导致任何内存泄漏呢？您可以确保以下几点：- 1:新建的数量等于删除2:打开的文件描述符是否关闭还有别的事吗？

问如何确保在编写C++代码本身时不会导致任何内存泄漏？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何确保在编写C++代码本身时不会导致任何内存泄漏？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何确保在编写C++代码本身时不会导致任何内存泄漏？
EN