blocks|key|2694272|text|使用reset()时，传递给reset的参数不必是托管对象(也不能是)；而使用=时，右侧必须是托管对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2694273|所以这两行代码给出了相同的最终结果：|2694274|p+=+std::make_shared<int>(5);+//+assign+to+a+newly+created+shared+pointer
p.reset(new+int(5));+//+take+control+of+a+newly+created+pointer|code-block|syntax|javascript|2694275|但我们不能：|2694276|p+=+new+int(5);+//+compiler+error+no+suitable+overload
p.reset(std::make_shared<int>(5).get());+//+uh+oh+undefined+behavior|2694277|如果没有reset()，您将无法将共享指针重新分配给不同的原始指针，除非创建一个共享指针并将其分配。如果没有=，你就不能让一个共享指针指向另一个共享指针。|2694278|entityMap^0|2|7|13|1|0|0|0|0|0|4|7|1I|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|T|$]]

When using <code>reset()</code> the parameter passed to reset need not be a managed object (nor can it be); whereas with <code>=</code> the right hand side must be a managed object.

So these two lines give you the same end result:

<pre><code>p = std::make_shared&lt;int&gt;(5); // assign to a newly created shared pointer
p.reset(new int(5)); // take control of a newly created pointer
</code></pre>

But we cannot do:

<pre><code>p = new int(5); // compiler error no suitable overload
p.reset(std::make_shared&lt;int&gt;(5).get()); // uh oh undefined behavior
</code></pre>

Without <code>reset()</code> you would not be able to reassign a shared pointer to a different raw pointer without creating a shared pointer and assigning it. Without <code>=</code> you wouldn't be able to make a shared pointer point to another shared pointer.

blocks|key|132939|text|我不会包含你的第一个子问题背后的原理，即通过make_shared构造和从指针构造之间的差异，因为这种差异在几个不同的位置突出显示，包括this+excellent+question。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|132940|但是，我认为区分使用reset和operator=是有建设性的。前者放弃对shared_ptr管理的资源的所有权，如果shared_ptr恰好是唯一的所有者，则通过销毁它，或者通过减少引用计数。后者意味着与另一个shared_ptr共享所有权(除非您正在移动构造)。|132941|正如我在注释中提到的，重要的是传递给reset的指针不属于另一个共享的或唯一的指针，因为它会在两个独立的管理器被破坏时产生未定义的行为-它们都会尝试delete资源。|132942|reset的一个用例可以是共享资源的延迟初始化。你只希望shared_ptr管理一些资源，比如内存，如果你真的需要它的话。执行完全分配，例如：|132943|std::shared_ptr<resource>+shared_resource(new+resource(/*construct+a+resource*/));|code-block|syntax|javascript|132944|如果它从来没有真正需要过，可能是浪费的。要使用延迟初始化来实现这一点，可以应用如下内容：|132945|std::shared_ptr<resource>+shared_resource;
void+use_resource()
{
+++++++if(!shared_resource)
+++++++{
++++++++++++shared_resource.reset(new+resource(...));
+++++++}

+++++++shared_resource->do_foo();
}|132946|在这种情况下使用reset比使用swap或分配给临时shared_ptr更简洁。|132947|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/20895648/difference-in-make-shared-and-normal-shared-ptr-in-c^0|M|B|1W|N|0|0|A|5|G|9|11|A|1N|A|2Y|A|0|I|5|22|6|0|0|5|S|A|0|0|0|0|8|5|G|4|Q|A|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|F|3|G|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|L|3|M|5|N|7|1V|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1W|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|1X|8|@]|D|@]|E|$O|P]]|$1|U|3|V|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

I won't include the rationale behind your first sub-question of the difference between construction via <code>make_shared</code> or from a pointer, as this difference is highlighted in several different locations, including <a href="https://stackoverflow.com/questions/20895648/difference-in-make-shared-and-normal-shared-ptr-in-c">this excellent question</a>. 

However, I think it is constructive to distinguish between using <code>reset</code> and <code>operator=</code>. The former relinquishes ownership of the resource managed by the <code>shared_ptr</code>, either by destroying it if the <code>shared_ptr</code> happened to be the sole owner, or by decrementing the reference count. The latter implies shared ownership with another <code>shared_ptr</code> (unless you're move constructing).

As I mentioned in the comments, it's important that the pointer passed in to <code>reset</code> not be owned by another shared or unique pointer, because it would yield undefined behavior upon the destruction of the two independent managers - they both would attempt to <code>delete</code> the resource.

One use case of <code>reset</code> could be lazy initialization of a shared resource. You only want the <code>shared_ptr</code> to manage some resource, memory for example, if you really need it. Doing an outright allocation, such as:

<pre><code>std::shared_ptr&lt;resource&gt; shared_resource(new resource(/*construct a resource*/));
</code></pre>

might be wasteful if its never actually needed. To do this with lazy initialization, something like this may apply:

<pre><code>std::shared_ptr&lt;resource&gt; shared_resource;
void use_resource()
{
 if(!shared_resource)
 {
 shared_resource.reset(new resource(...));
 }

 shared_resource-&gt;do_foo();
}
</code></pre>

Using <code>reset</code> in this case is more concise than doing a <code>swap</code> or assigning to a temporary <code>shared_ptr</code>.

blocks|key|132478|text|reset()更改现有shared_ptr的托管对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|132479|132480|+p=+std::shared_ptr(new+int(5))；和p.reset(new+int(5))；|blockquote|132481|132482|132483|前者涉及创建一个新的shared_ptr并将其移动到一个变量中。后者不会创建新的对象，它只是更改由shared_ptr管理的底层指针。|132484|换句话说，这两种方法的用法是不同的。赋值用于当你有一个shared_ptr和reset时，当你有一个原始指针的时候。|132485|另一件要记住的事情是，在移动分配存在之前，shared_ptr在boost中就已经可用了，并且对最新版本产生了很大的影响。无需移动分配，无需制作副本即可更改shared_ptr是有益的，因为它为您节省了额外对象的记账。|132486|entityMap^0|0|7|B|A|0|0|0|0|0|A|A|1D|A|0|R|A|12|5|0|L|A|26|A|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|Z|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|10|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|11|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|S|$]]

<code>reset()</code> changes the managed object of an existing <code>shared_ptr</code>.

<blockquote>
 p = std::shared_ptr(new int(5)); and p.reset(new int(5));
</blockquote>

The former involves creating a new <code>shared_ptr</code> and moving it into a variable. The latter does not create a new object, it simply changes the underlying pointer in managed by the <code>shared_ptr</code>.

Put another way the two are meant to be used in different cases. Assignment is for when you have a <code>shared_ptr</code> and <code>reset</code> for when you have a raw pointer.

Another thing to keep in mind is that <code>shared_ptr</code> was available in boost before move assignment existed and influenced the latest version heavily. Without move assignment being able to change a <code>shared_ptr</code> without making a copy is beneficial as it saves you the bookkeeping of the extra object.

blocks|key|2694542|text|在某些情况下，reset可以避免动态内存分配。考虑一下代码|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2694543|std::shared_ptr<int>+p{new+int{}};++//+1
p.reset(new+int{});+++++++++++++++++//+2|code-block|syntax|javascript|2694544|在第1行，发生了2次动态内存分配，一次用于int对象，另一次用于shared_ptr的控制块，用于跟踪对托管对象的强/弱引用的数量。|2694545|在第2行，有一个新的int对象的动态内存分配。在reset的主体内，shared_ptr将确定没有其他对以前管理的int的强引用，因此它必须delete它。因为也没有任何弱引用，所以它也可以释放控制块，但在这种情况下，实现重用相同的控制块将是谨慎的，因为它无论如何都必须分配一个新的控制块。|2694546|如果您必须始终使用赋值，则上述行为是不可能的。|2694547|std::shared_ptr<int>+p{new+int{}};++++//+1
p+=+std::shared_ptr<int>{new+int{}};++//+2|2694548|在本例中，对第2行的shared_ptr构造函数的第二次调用已经分配了一个控制块，因此p将不得不释放它自己的现有控制块。|2694549|entityMap^0|7|5|0|0|L|3|W|A|0|A|3|O|5|Y|A|1L|3|1Y|6|0|0|0|A|A|17|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|V|$]]

It's possible for <code>reset</code> to avoid a dynamic memory allocation in certain cases. Consider the code

<pre><code>std::shared_ptr&lt;int&gt; p{new int{}}; // 1
p.reset(new int{}); // 2
</code></pre>

On line 1 there are 2 dynamic memory allocations happening, one for the <code>int</code> object and a second one for the <code>shared_ptr</code>'s control block that'll keep track of the number of strong/weak references to the managed object.

On line 2 there is again a dynamic memory allocation for a new <code>int</code> object. Within the body of <code>reset</code> the <code>shared_ptr</code> will determine that there are no other strong references to the previously managed <code>int</code>, so it must <code>delete</code> it. Since there aren't any weak references either, it could also deallocate the control block, but in this case it would be prudent for the implementation to reuse the same control block because it would otherwise have to allocate a new one anyway.

The above behavior would not be possible if you always had to use assignment.

<pre><code>std::shared_ptr&lt;int&gt; p{new int{}}; // 1
p = std::shared_ptr&lt;int&gt;{new int{}}; // 2
</code></pre>

In this case, the second call to the <code>shared_ptr</code> constructor on line 2 has already allocated a control block, so <code>p</code> will have to deallocate its own existing control block.

This is a basic question, but I did not find a previous post about it. The title of the following question sounds like it might be the same question as mine, but the question itself does not match the title: <a href="https://stackoverflow.com/questions/14836691/is-it-better-to-use-shared-ptr-reset-or-operator">is it better to use shared_ptr.reset or operator =?</a>

I am confused about the purpose of the <code>reset()</code> member function of <code>std::shared_ptr</code>: what does it contribute in addition to the assignment operator?

To be concrete, given the definition:

<pre><code>auto p = std::make_shared&lt;int&gt;(1);
</code></pre>

<ol>
<li>Are the following two lines equivalent:

<pre><code>p = std::make_shared&lt;int&gt;(5);
p.reset(new int(5));
</code></pre></li>
<li>What about these:

<pre><code>p = nullptr;
p.reset();
</code></pre></li>
</ol>

If the two lines are equivalent in both cases, then what is the purpose of <code>reset()</code>? 

<hr>

EDIT: Let me re-phrase the question to better emphasize its point. The question is: is there a case where <code>reset()</code> lets us achieve something that is not as easily achievable without it?

std::shared_ptr: reset() vs. assignment

这是一个基本的问题，但我没有找到之前关于它的帖子。以下问题的标题听起来可能与我的问题相同，但问题本身与标题不匹配：我对std::shared_ptr的reset()成员函数的用途感到困惑:除了赋值运算符之外，它还贡献了什么？具体地说，给出了定义：auto p = std::make_shared<int>(1);是以下...

问std::shared_ptr: reset()与赋值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::shared_ptr: reset()与赋值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::shared_ptr: reset()与赋值
EN