blocks|key|484468|text|如果你不知道什么时候应该使用指针，那就不要使用它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|484469|当你需要使用它们时，它会变得很明显，每种情况都是不同的。要简明扼要地总结出什么时候应该使用它们并不容易。不要养成“总是对对象使用指针”的习惯，这肯定是个坏建议。|484470|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|$]]

If you don't know when you should use pointers just don't use them.

It will become apparent when you need to use them, every situation is different. It is not easy to sum up concisely when they should be used. Do not get into the habit of 'always using pointers for objects', that is certainly bad advice.

blocks|key|3703276|text|使用指针的主要原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3703277|3703278|控件对象生存期；|ordered-list-item|3703279|不能使用引用(例如，您希望以矢量形式存储不可复制的内容)；|3703280|您应该将指针传递给某个第三方函数；|3703281|可能出于某些优化原因，但我不确定。|3703282|<代码>G29|3703283|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Main reasons for using pointers:

<ol>
<li>control object lifetime; </li>
<li>can't use references (e.g. you want to store something non-copyable in vector); </li>
<li>you should pass pointer to some third party function; </li>
<li>maybe some optimization reasons, but I'm not sure.</li>
</ol>

blocks|key|4549583|text|我不清楚你的问题是ptr-+to+-obj还是ptr-to-obj还是ptr-to-obj还是引用到obj。也有一些用途不属于这两个类别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4549584|关于vs堆栈，上面似乎已经介绍过了。有几个原因，最明显的是对象的生命周期。|4549585|关于vs引用，总是努力使用引用，但有一些事情你只能用ptrs来做，例如(有很多用法)：|4549586|4549587|遍历数组中的元素(例如，遍历标准array[])|unordered-list-item|4549588|当被调用的函数分配某些内容并通过ptr|4549589|返回它时|4549590|最重要的是，指针(和引用，而不是自动/基于堆栈的静态对象)支持多态性。指向基类的指针实际上可能指向派生类。这是C%2B%2B中支持的OO行为的基础。|offset|length|style|BOLD|4549591|entityMap^0|0|0|0|0|0|0|0|0|1Y|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@$P|13|Q|14|R|S]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|U|$]]

It's not clear to me if your question is ptr-to-obj vs stack-based-obj or ptr-to-obj vs reference-to-obj. There are also uses that don't fall into either category.

Regarding vs stack, that seems to already be covered above. Several reasons, most obvious is lifetime of object.

Regarding vs references, always strive to use references, but there are things you can do only with ptrs, for example (there are many uses):

<ul>
<li>walking through elements in an array (e.g., marching over a standard array[])</li>
<li>when a called function allocates something &amp; returns it via a ptr</li>
</ul>

Most importantly, pointers (and references, as opposed to automatic/stack-based &amp; static objects) support polymorphism. A pointer to a base class may actually point to a derived class. This is fundamental to the OO behavior supported in C++.

blocks|key|4549643|text|首先，问题是错误的:困境不是在指针和堆栈之间，而是在堆和堆栈之间。您可以将对象放在堆栈上，并将指针传递给该对象。我假设你真正想问的是你是应该声明一个指向类的指针还是一个类的实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4549644|答案是，这取决于您想要对对象做什么。如果对象必须在控件离开函数后存在，则必须使用指针并在堆上创建对象。例如，当您的函数必须返回指向创建的对象的指针或将该对象添加到调用函数之前创建的列表时，您将执行此操作。|4549645|另一方面，如果对象是函数的局部对象，那么最好在堆栈上使用它。这使编译器能够在控件离开函数时调用析构函数。|4549646|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|1108598|text|这些教程是什么？实际上，规则是只有在万不得已的情况下才应该使用指针，这种情况非常少见。你需要读一本关于C%2B%2B的好书，比如Koenig+&+Moo的Accelerated+C%2B%2B。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1108599|编辑：来澄清一下--在两个实例中，你不会使用指针(字符串在这里用作样本--对于任何其他类型也是如此)：|style|BOLD|1108600|class+Person+{
+++public:
++++++string+name;+++++++//+NOT+string+*+name;
+++...
};


void+f()+{
+++string+value;++++++++//+NOT+string+*+value
+++//+use+vvalue
}|code-block|syntax|javascript|1108601|entityMap|0|LINK|mutability|MUTABLE|url|http://www.acceleratedcpp.com/^0|21|F|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@$A|Z|B|10|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|11|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Which tutorials would those be? Actually, the rule is that you should use pointers only when you absolutely have to, which is quite rarely. You need to read a good book on C++, like <a href="http://www.acceleratedcpp.com/" rel="nofollow noreferrer">Accelerated C++</a> by Koenig &amp; Moo.

Edit: To clarify a bit - two instances where you would not use a pointer (string is being used here as an exemplar - same would go for any other type):

<pre><code>class Person {
 public:
 string name; // NOT string * name;
 ...
};


void f() {
 string value; // NOT string * value
 // use vvalue
}
</code></pre>

blocks|key|1108669|text|在以下情况下，您通常需要使用指针：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1108670|1108671|您需要一个属于不同类的对象集合(在大多数情况下，它们具有一个公用基)。|ordered-list-item|1108672|您需要一个堆栈分配的对象集合，该集合非常大，可能会导致堆栈溢出。|1108673|您需要一种可以快速重新排列对象的数据结构，如链表、树和类似的对象。|1108674|您需要一些复杂的对象生存期管理逻辑。|1108675|H19您需要一种允许直接从对象导航到对象的数据结构，如链表、树或任何其他图形。<代码>H210<代码>G211|1108676|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

You usually have to use pointers in the following scenarios:

<ol>
<li>You need a collection of objects that belong to different classes (in most cases they will have a common base).</li>
<li>You need a stack-allocated collection of objects so large that it'll likely cause stack overflow.</li>
<li>You need a data structure that can rearrange objects quickly - like a linked list, tree ar similar.</li>
<li>You need some complex logic of lifetime management for your object.</li>
<li>You need a data structure that allows for direct navigation from object to object - like a linked list, tree or any other graph.</li>
</ol>

blocks|key|4549541|text|除了其他人提出的观点(特别是w.r.t.控制对象的生存期)，如果你需要处理空对象，你应该使用指针，而不是引用。可以通过类型转换创建空引用，但这通常不是一个好主意。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4549542|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|4549407|text|通常在以下情况下使用指向对象的指针/引用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4549408|将它们传递给其他methods|4549409|creating一个大数组(我不确定正常的堆栈大小是多少)|unordered-list-item|4549410|4549411|4549412|4549413|在以下情况下使用堆栈：|4549414|4549415|您正在创建一个在方法|4549416|中存在和终止的对象该对象的大小相当于CPU寄存器或更小的|4549417|4549418|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|W|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|S|$]]

Generally use pointers / references to objects when:

<ul>
<li>passing them to other methods</li>
<li>creating a large array (I'm not sure what the normal stack size is)</li>
</ul>

Use the stack when:

<ul>
<li>You are creating an object that lives and dies within the method</li>
<li>The object is the size of a CPU register or smaller</li>
</ul>

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

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

++++Bar&+Bar()+const+{+return+*bar;+}
};|code-block|syntax|javascript|4549560|在此之前，我使用了从构造函数初始化的引用成员，但编译器在创建复制构造函数、赋值操作符和批处理时遇到了问题。|4549561|戴夫|4549562|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|3703575|text|使用指针与两个正交的东西相关：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3703576|3703577|Dynamic分配。通常，当对象的生存期比创建它的作用域更长时，您应该动态分配。这样的对象是必须明确指定其所有者的资源(最常见的是通过地址的某种智能pointer).|ordered-list-item|offset|length|style|BOLD|3703578|Accessing+(不管对象是如何创建的)。在这种情况下，指针并不意味着所有权。在下列情况下可能需要这样的访问：|3703579|3703580|-+some+already+existing+interface+requires+that.
-+association+which+could+be+null+should+be+modeled.
-+copying+of+large+objects+should+be+avoided+or+copying+is+impossible+at+all,+but+the+reference+can't+be+used+(e.g.,+stl+collections).|code-block|syntax|javascript|3703581|​|3703582|#1和#2可以出现在不同的配置中，例如，您可以想象通过指针访问动态分配的对象，但这样的对象也可以通过引用某个函数来传递。你还可以获取指向某个对象的指针，这些对象是在堆栈上创建的。|3703583|entityMap^0|0|0|0|9|0|0|1L|0|0|0|0|1|0|0|2H|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Z|8|@$F|10|G|11|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|12|8|@$F|13|G|14|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|16|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|17|8|@$F|18|G|19|H|I]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1A|8|@$F|1B|G|1C|H|I]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|W|$]]

using pointers is connected with two orthogonal things:

<ol>
<li>Dynamic allocation. In general, you should allocate dynamically, when the object is intended to live longer that the scope in which it's created. Such an object is a resource which owner have to be clearly specified (most commonly some sort of smart pointer).</li>
<li>Accessing by address (regardless of how the object was created). In this context pointer doesn't mean ownership. Such accessing could be needed when:

<ul>
<li>some already existing interface requires that.</li>
<li>association which could be null should be modeled.</li>
<li>copying of large objects should be avoided or copying is impossible at all, but the reference can't be used (e.g., stl collections).</li>
</ul></li>
</ol>

The #1 and #2 can occur in different configurations, for example you can imagine dynamically allocated object accessed by pointer, but such the object could also by passed by reference to some function. You also can get pointer to some object which is created on the stack, etc.

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

blocks|key|4549435|text|如果不希望在清空堆栈帧时销毁对象，请使用指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4549436|在可能的情况下，使用引用传递参数。|4549437|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|484717|text|说到C%2B%2B，当程序离开创建它的作用域时，在堆栈上创建的对象就不能使用。因此，通常情况下，当你知道在函数后面或右大括号后面不需要变量时，你可以在堆栈上创建它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|484718|具体说到Qt，Qt可以帮助程序员处理堆对象的大量内存管理。对于派生自QObject的对象(几乎所有以"Q“为前缀的类都是)，构造函数接受一个可选的参数parent。然后，父对象拥有该对象，当删除父对象时，所有拥有的对象也将被删除。本质上，子对象的销毁责任被传递给父对象。使用此机制时，必须在堆上创建子QObject。|offset|length|style|CODE|484719|简而言之，在Qt中，你可以很容易地在堆上创建对象，只要你设置了一个合适的父对象，你只需要担心销毁这个父对象。但是，在一般的C%2B%2B中，您需要记住销毁堆对象，或者使用智能指针。|484720|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.

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?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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