blocks|key|1387398|text|如果不希望在清空堆栈帧时销毁对象，请使用指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1387399|在可能的情况下，使用引用传递参数。|1387400|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|$]]

Use pointers when you don't want your object to be destroyed when the stack frame is emptied.

Use references for passing parameters where possible.

blocks|key|1387431|text|除了其他人提出的观点(特别是w.r.t.控制对象的生存期)，如果你需要处理空对象，你应该使用指针，而不是引用。可以通过类型转换创建空引用，但这通常不是一个好主意。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1387432|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 addition to points others make (esp. w.r.t. controlling the object lifetime), if you need to handle NULL objects, you should use pointers, not references. It's possible to create a NULL reference through typecasting, but it's generally a bad idea.

blocks|key|1602327|text|在这种情况下，我实际上使用指针：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1602328|class+Foo
{
++++Bar*+bar;

++++Foo(Bar&+bar)+:+bar(&bar)+{+}

++++Bar&+Bar()+const+{+return+*bar;+}
};|code-block|syntax|javascript|1602329|在此之前，我使用了从构造函数初始化的引用成员，但编译器在创建复制构造函数、赋值操作符和批处理时遇到了问题。|1602330|戴夫|1602331|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I actually use pointers in this situation:

<pre><code>class Foo
{
 Bar* bar;

 Foo(Bar&amp; bar) : bar(&amp;bar) { }

 Bar&amp; Bar() const { return *bar; }
};
</code></pre>

Before that, I used reference members, initialized from the constructor, but the compiler has a problem creating copy constructors, assignment operators, and the lot. 

Dave

blocks|key|1602364|text|首先，问题是错误的:困境不是在指针和堆栈之间，而是在堆和堆栈之间。您可以将对象放在堆栈上，并将指针传递给该对象。我假设你真正想问的是你是应该声明一个指向类的指针还是一个类的实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1602365|答案是，这取决于您想要对对象做什么。如果对象必须在控件离开函数后存在，则必须使用指针并在堆上创建对象。例如，当您的函数必须返回指向创建的对象的指针或将该对象添加到调用函数之前创建的列表时，您将执行此操作。|1602366|另一方面，如果对象是函数的局部对象，那么最好在堆栈上使用它。这使编译器能够在控件离开函数时调用析构函数。|1602367|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|$]]

First off, the question is wrong: the dilemma is not between pointers and stack, but between heap and stack. You can have an object on the stack and pass the pointer to that object. I assume what you are really asking is whether you should declare a pointer to class or an instance of class.

The answer is that it depends on what you want to do with the object. If the object has to exist after the control leaves the function, then you have to use a pointer and create the object on heap. You will do this, for example, when your function has to return the pointer to the created object or add the object to a list that was created before calling your function.

On the other hand, if the objects is local to the function, then it is better to use it on stack. This enables the compiler to call the destructor when the control leaves the function.

blocks|key|1387536|text|通过行为良好的可复制对象传递值是获取大量代码的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1387537|如果速度真的很重要，请尽可能使用按引用传递，最后使用指针。|1387538|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|$]]

Pass by value with well behaved copyable objects is the way to go for a large amount of your code.

If speed really matters, use pass by reference where you can, and finally use pointers.

blocks|key|1387565|text|说到C%2B%2B，当程序离开创建它的作用域时，在堆栈上创建的对象就不能使用。因此，通常情况下，当你知道在函数后面或右大括号后面不需要变量时，你可以在堆栈上创建它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1387566|具体说到Qt，Qt可以帮助程序员处理堆对象的大量内存管理。对于派生自QObject的对象(几乎所有以"Q“为前缀的类都是)，构造函数接受一个可选的参数parent。然后，父对象拥有该对象，当删除父对象时，所有拥有的对象也将被删除。本质上，子对象的销毁责任被传递给父对象。使用此机制时，必须在堆上创建子QObject。|offset|length|style|CODE|1387567|简而言之，在Qt中，你可以很容易地在堆上创建对象，只要你设置了一个合适的父对象，你只需要担心销毁这个父对象。但是，在一般的C%2B%2B中，您需要记住销毁堆对象，或者使用智能指针。|1387568|entityMap^0|0|Y|7|1F|1|46|7|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]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

Speaking about C++, objects created on the stack cannot be used when the program has left the scope it was created in. So generally, when you know you don't need a variable past a function or past a close brace, you can create it on the stack.

Speaking about Qt specifically, Qt helps the programmer by handling a lot of the memory management of heap objects. For objects that are derived from <code>QObject</code> (almost all classes prefixed by "<code>Q</code>" are), constructors take an optional parameter parent. The parent then owns the object, and when the parent is deleted, all owned objects are deleted as well. In essence, the responsibility of the children's destruction is passed to the parent object. When using this mechanism, child <code>QObject</code>s must be created on the heap.

In short, in Qt you can easily create objects on the heap, and as long as you set a proper parent, you'll only have to worry about destroying the parent. In general C++, however, you'll need to remember to destroy heap objects, or use smart pointers.

blocks|key|1602451|text|如果可能的话，永远不要使用指针。依赖于通过引用传递，或者如果你要返回一个结构或类，假设你的编译器有返回值优化。(但是，您必须避免返回类的条件构造)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1602452|Java没有指针是有原因的。C%2B%2B也不需要它们。如果您避免使用它们，那么当对象离开作用域时，您将获得自动对象销毁的额外好处。否则，您的代码将生成各种类型的内存错误。内存泄漏很难发现，而且由于未处理的异常，在C%2B%2B中经常会发生。|1602453|如果您必须使用指针，请考虑一些智能指针类，如auto_ptr。对象的自动销毁不仅仅是释放底层内存。有一个叫做RAII的概念。有些对象需要额外处理销毁。例如互斥和关闭文件等。|1602454|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|$]]

If possible never use pointers. Rely on pass by reference or if you are going to return a structure or class, assume that your compiler has return value optimization. (You have to avoid conditional construction of the returned class however).

There is a reason why Java doesn't have pointers. C++ doesn't need them either. If you avoid their use you will get the added benefit of automatic object destruction when the object leaves scope. Otherwise your code will be generating memory errors of various types. Memory leaks can be very tricky to find and often occur in C++ due to unhandled exceptions.

If you must use pointers, consider some of the smart pointer classes like auto_ptr. Auto destruction of objects is more than just releasing the underlying memory. There is a concept called RAII. Some objects require additionally handing on destruction. e.g. mutexes and closing files etc.

After reading some tutorials I came to the conclusion that one should always use pointers for objects. But I have also seen a few exceptions while reading some QT tutorials (<a href="http://zetcode.com/gui/qt4/painting/" rel="nofollow noreferrer">http://zetcode.com/gui/qt4/painting/</a>) where QPaint object is created on the stack. So now I am confused. When should I use pointers?

c++: when to use pointers?

内存管理

编译器

Java

在阅读了一些教程后，我得出结论，一个人应该总是使用对象的指针。但在阅读一些在堆栈上创建QPaint对象的QT教程()时，我也看到了一些例外。所以现在我很困惑。什么时候应该使用指针？

问c++：什么时候使用指针？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++：什么时候使用指针？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++：什么时候使用指针？
EN