blocks|key|2029538|text|首先，我认为应该是Foo+*f+=+new+Foo();|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2029539|我不喜欢使用这种语法的原因是，很容易忘记在代码末尾添加delete，从而导致内存泄漏。|2029540|entityMap^0|9|J|0|R|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

First of all, i believe it should be <code>Foo *f = new Foo();</code>

And the reason I don't like using that syntax because it is easy to forget to add a <code>delete</code> at the end of the code and leave your memory a-leakin'.

blocks|key|1816629|text|使用某种智能指针方案，您可以获得自动内存管理、引用计数等功能，并且只需很少的开销。你要为此付出代价(在内存或性能上)，但这可能是值得的，而不是必须一直担心它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1816630|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|$]]

With some kind of smart pointer scheme you can get automatic memory management, reference counting, etc., with only a small amount of overhead. You pay for that (in memory or performance), but it may be worth it to pay for it instead of having to worry about it all the time.

blocks|key|1816844|text|不是的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1816845|在某些情况下，有很好的理由不使用自动内存管理系统。这些可以是性能、由于循环引用而导致的数据结构的复杂性等。|1816846|然而，如果你有充分的理由不使用一些更智能的东西，我建议只使用带有new/malloc的原始指针。看到无保护的分配让我害怕，让我希望程序员知道他们在做什么。|1816847|像boost::shared_ptr，boost::scoped_ptr这样的智能指针类将是一个很好的开始。(这些将是C%2B%2B0x标准的一部分，所以不要害怕;)|1816848|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

No.

There are very good reasons to not use automatic memory management systems in certain cases.
These can be performance, complexity of data structures due to cyclical referencing etc.

However I recommend only using a raw poiner with new/malloc if ou have a good reason to not use somehting smarter. Seeing unprotected allocations scares me and makes me hope the coder knows what they're doing.

Some kind of smart pointer class like boost::shared_ptr, boost::scoped_ptr would be a good start. ( These will be part of the C++0x standard so dont be scared of them ;) )

blocks|key|2030314|text|这个例子非常像Java。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2030315|在C%2B%2B中，我们只在需要时才使用动态内存管理。|2030316|更好的替代方法是声明一个局部变量。|2030317|{
++++Foo++++f;

++++//+use+f

}+//+f+goes+out+of+scope+and+is+immediately+destroyed+here.|code-block|syntax|javascript|2030318|如果必须使用动态内存，则使用智能指针。|2030319|//+In+C%2B%2B14
{
++++std::unique_ptr<Foo>++f+=+std::make_unique<Foo>();+//+no+need+for+new+anymore
}

//+In+C%2B%2B11
{
++++std::unique_ptr<Foo>++f(new+Foo);++//+See+Description+below.
}

//+In+C%2B%2B03
{
++++std::auto_ptr<Foo>++++f(new+Foo);++//+the+smart+pointer+f+owns+the+pointer.
+++++++++++++++++++++++++++++++++++++++//+At+some+point+f+may+give+up+ownership+to+another
+++++++++++++++++++++++++++++++++++++++//+object.+If+not+then+f+will+automatically+delete
+++++++++++++++++++++++++++++++++++++++//+the+pointer+when+it+goes+out+of+scope..

}|2030320|有一大堆os智能指针提供了int+std:：和boost:：(现在有一些在std：：tr1中)选择合适的指针并使用它来管理对象的生命周期。|2030321|请参阅Smart+Pointers:+Or+who+owns+you+baby?|offset|length|2030322|从技术上讲，您可以使用new/delete来进行内存管理。|2030323|但在真正的C%2B%2B代码中，几乎从来没有这样做过。与手动进行内存管理相比，几乎总是有更好的替代方案。|2030324|std::vector就是一个简单的例子。在幕后，它使用new和delete。但你永远不能从外面看出来。这对类的用户来说是完全透明的。用户所知道的就是向量将拥有该对象的所有权，并且当该向量被销毁时，它将被销毁。|2030325|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/94227/smart-pointers-or-who-owns-you-baby^0|0|0|0|0|0|0|0|3|11|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@$S|1G|T|1H|1|1I]]|A|$]]|$1|U|3|V|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]]]

This example is very Java like. 
In C++ we only use dynamic memory management if it is required. 
A better alternative is just to declare a local variable.

<pre><code>{
 Foo f;

 // use f

} // f goes out of scope and is immediately destroyed here.
</code></pre>

If you must use dynamic memory then use a smart pointer. 

<pre><code>// In C++14
{
 std::unique_ptr&lt;Foo&gt; f = std::make_unique&lt;Foo&gt;(); // no need for new anymore
}

// In C++11
{
 std::unique_ptr&lt;Foo&gt; f(new Foo); // See Description below.
}

// In C++03
{
 std::auto_ptr&lt;Foo&gt; f(new Foo); // the smart pointer f owns the pointer.
 // At some point f may give up ownership to another
 // object. If not then f will automatically delete
 // the pointer when it goes out of scope..

}
</code></pre>

There are a whole bunch os smart pointers provided int std:: and boost:: (now some are in std::tr1) pick the appropriate one and use it to manage the lifespan of your object.

See <a href="https://stackoverflow.com/questions/94227/smart-pointers-or-who-owns-you-baby">Smart Pointers: Or who owns you baby?</a>

Technically you can use new/delete to do memory management. 
But in real C++ code it is almost never done. There is nearly always a better alternative to doing memory management by hand.

A simple example is the std::vector. Under the covers it uses new and delete. But you would never be able to tell from the outside. This is completely transparent to the user of the class. All that the user knows is that the vector will take ownership of the object and it will be destroyed when the vector is destroyed.

blocks|key|2030360|text|我认为，所有这些"...best实践“的问题……问题是他们都是在没有上下文的情况下考虑代码。如果你问“一般来说”，我不得不承认直接内存管理是完全可以接受的。它在语法上是合法的，并且不违反任何语言语义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2030361|至于替代方案(堆栈变量、智能指针等)，它们都有自己的缺点。它们都没有直接内存管理所具有的灵活性。您必须为这种灵活性付出的代价是调试时间，并且您应该意识到所有风险。|2030362|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|$]]

I think, the problem of all these "...best practices..." questions is that they all consider the code without context. If you ask "in general", I have to admit that direct memory management is perfectly acceptable. It is syntactically legal and it does not violate any language semantics.

As for the alternatives (stack variables, smart pointers etc), they all have their drawbacks. And none of them have the flexibility, the direct memory management have. The price you have to pay for such a flexibility is your debugging time, and you should be aware of all risks.

blocks|key|1816991|text|如果您使用的是异常，那么这类代码实际上肯定会导致资源泄漏。即使您禁用了异常，当手动将new与delete配对时，清理也非常容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1816992|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 are using exceptions that kind of code is practically guaranteed to lead to recource leaks. Even if you disable exceptions, cleaning up is very easy to srew up when manually pairing new with delete.

blocks|key|2030553|text|一般来说，您的示例不是异常安全的，因此不应该使用。如果紧跟在新的抛出之后的行抛出？堆栈展开，您刚刚泄漏了内存。作为堆栈展开的一部分，智能指针将为您处理它。如果你倾向于不处理异常，那么在RAII问题之外就没有回调。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2030554|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|$]]

In general your example is not exception safe and therefore shouldn't be used. If the line directly following the new throws? The stack unwinds and you have just leaked memory. A smart pointer will take care of it for you as part of the stack unwind. If you tend to not handle exceptions then there is no draw back outside of RAII issues.

Reading through an old C++ Journal I had, I noticed something.

One of the articles asserted that

<code>Foo *f = new Foo();</code>

was nearly unacceptable professional C++ code by and large, and an automatic memory management solution was appropriate.

Is this so?

edit: rephrased: is direct memory management unacceptable for new C++ code, in general? Should auto_ptr(or the other management wrappers) be used for most new code?

Is Foo* f = new Foo good C++ code

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

翻阅我的一本旧的C++杂志，我注意到了一些东西。其中一篇文章断言Foo *f = new Foo();基本上是几乎不可接受的专业C++代码，自动内存管理解决方案是合适的。是这样吗？编辑:重新表述:通常情况下，直接内存管理对于新的C++代码是不可接受的吗？对于大多数新代码，是否应该使用auto_ptr(或其他管理包装器)...

问Is Foo* f= new Foo good C++代码
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Is Foo* f= new Foo good C++代码EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Is Foo* f= new Foo good C++代码
EN