blocks|key|1003566|text|shared_ptr将引用计数机制包装在原始指针周围。因此，对于shared_ptr的每个实例，引用计数加1。如果两个share_ptr对象互相引用，它们将永远不会被删除，因为它们永远不会以引用计数为零结束。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1003567|weak_ptr指向一个shared_ptr，但不增加它的引用count.This意味着即使存在对它的weak_ptr引用，也仍然可以删除下面的对象。|1003568|其工作方式是，无论何时想要使用底层对象，都可以使用weak_ptr为创建shared_ptr。但是，如果该对象已被删除，则返回一个空的shared_ptr实例。由于基础对象上的引用计数不会随着weak_ptr引用而增加，因此循环引用不会导致基础对象不被删除。|1003569|entityMap^0|0|A|W|A|1N|9|0|0|8|C|A|1F|8|0|P|8|10|A|1V|A|2O|8|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|K|$]]

A <code>shared_ptr</code> wraps a reference counting mechanism around a raw pointer. So for each instance of the <code>shared_ptr</code> the reference count is increased by one. If two <code>share_ptr</code> objects refer the eachother they will never get deleted because they will never end up with a reference count of zero.

<code>weak_ptr</code> points to a <code>shared_ptr</code> but does not increase its reference count.This means that the underying object can still be deleted even though there is a <code>weak_ptr</code> reference to it.

The way that this works is that the <code>weak_ptr</code> can be use to create a <code>shared_ptr</code> for whenever one wants to use the underlying object. If however the object has already been deleted then an empty instance of a <code>shared_ptr</code> is returned. Since the reference count on the underlying object is not increased with a <code>weak_ptr</code> reference, a circular reference will not result in the underlying object not being deleted.

blocks|key|1003654|text|以上所有答案都是错误的。weak_ptr不是用来中断循环引用的，它们有另一个用途。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1003655|基本上，如果所有的shared_ptr(s)都是由make_shared()或allocate_shared()调用创建的，那么如果除了内存之外没有其他资源需要管理，那么就永远不需要weak_ptr。这些函数使用对象本身创建shared_ptr引用计数器对象，同时释放内存。|1003656|weak_ptr和shared_ptr之间的唯一区别是weak_ptr允许在实际对象释放后保留引用计数器对象。因此，如果您在std::set中保留了大量shared_ptr，如果实际对象足够大，则它们将占用大量内存。这个问题可以通过使用weak_ptr来解决。在这种情况下，您必须确保容器中存储的weak_ptr在使用前未过期。|1003657|entityMap^0|C|8|0|9|D|P|D|13|H|2J|8|34|A|0|0|8|9|A|R|8|1Q|8|24|A|3A|8|44|8|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|K|$]]

All the above answer are WRONG. <code>weak_ptr</code> is NOT used to break cyclic references, they have another purpose.

Basically, if all <code>shared_ptr(s)</code> were created by <code>make_shared()</code> or <code>allocate_shared()</code> calls, you will NEVER need <code>weak_ptr</code> if you have no resource other than memory to manage. These functions create the <code>shared_ptr</code> reference counter object with the object itself, and the memory will be freed at the same time.

The only difference between <code>weak_ptr</code> and <code>shared_ptr</code> is that the <code>weak_ptr</code> allows the reference counter object to be kept after the actual object was freed. As a result, if you keep a lot of <code>shared_ptr</code> in a <code>std::set</code> the actual objects will occupy a lot of memory if they are big enough. This problem can be solved by using <code>weak_ptr</code> instead. In this case, you have to ensure the <code>weak_ptr</code> stored in the container is not expired before using it.

blocks|key|1003723|text|给未来的读者。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1003724|我只想指出，Atom给出的解释非常好，下面是工作代码|1003725|#include+<memory>+//+and+others
using+namespace+std;

++++class+B;+//+forward+declaration+
++++//+for+clarity,+add+explicit+destructor+to+see+that+they+are+not+called
++++class+A+{+public:+shared_ptr+b;+~A()+{cout+<<+"~A()"+<<+endl;+}+};++
++++class+B+{+public:+shared_ptr<A>+a;+~B()+{cout+<<+"~B()"+<<+endl;+}+};+++++
++++shared_ptr<A>+x(new+A);++//x->b+share_ptr+is+default+initialized
++++x->b+=+make_shared();+//+you+can't+do+"=+new+B"+on+shared_ptr++++++++++++++++++++++
++++x->b->a+=+x;
++++cout+<<+x.use_count()+<<+endl;++|code-block|syntax|javascript|1003726|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For future readers. 
Just want to point out that explanation given by Atom is excellent, here is working code

<pre><code>#include &lt;memory&gt; // and others
using namespace std;

 class B; // forward declaration 
 // for clarity, add explicit destructor to see that they are not called
 class A { public: shared_ptr&lt;B&gt; b; ~A() {cout &lt;&lt; "~A()" &lt;&lt; endl; } }; 
 class B { public: shared_ptr&lt;A&gt; a; ~B() {cout &lt;&lt; "~B()" &lt;&lt; endl; } }; 
 shared_ptr&lt;A&gt; x(new A); //x-&gt;b share_ptr is default initialized
 x-&gt;b = make_shared&lt;B&gt;(); // you can't do "= new B" on shared_ptr 
 x-&gt;b-&gt;a = x;
 cout &lt;&lt; x.use_count() &lt;&lt; endl; 
</code></pre>

blocks|key|789873|text|弱指针只是“观察”托管对象；它们不会“让它存活”，也不会影响它的生命周期。与shared_ptr不同，当最后一个weak_ptr超出作用域或消失时，指向的对象仍然可以存在，因为weak_ptr不会影响对象的生存期-它没有所有权。weak_ptr可用于确定对象是否存在，并提供可用于引用该对象的shared_ptr。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|789874|weak_ptr的定义旨在使其相对简单，因此您几乎不能直接使用weak_ptr进行操作。例如，您不能取消引用它；operator*和operator->都不是为weak_ptr定义的。你不能用它来访问指向对象的指针--没有get()函数。这里定义了一个比较函数，以便您可以将weak_ptrs存储在有序容器中，但仅此而已。|789875|entityMap^0|12|A|1K|8|2G|8|36|8|42|A|0|0|8|V|8|1K|9|1U|A|28|8|33|5|3T|9|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|I|$]]

Weak pointers just "observe" the managed object; they don't "keep it alive" or affect its lifetime. Unlike <code>shared_ptr</code>, when the last <code>weak_ptr</code> goes out of scope or disappears, the pointed-to object can still exist because the <code>weak_ptr</code> does not affect the lifetime of the object - it has no ownership rights. The <code>weak_ptr</code> can be used to determine whether the object exists, and to provide a <code>shared_ptr</code> that can be used to refer to it.

The definition of <code>weak_ptr</code> is designed to make it relatively foolproof, so as a result there is very little you can do directly with a <code>weak_ptr</code>. For example, you can't dereference it; neither <code>operator*</code> nor <code>operator-&gt;</code> is defined
for a <code>weak_ptr</code>. You can't access the pointer to the object with it - there is no <code>get()</code> function. There is a comparison function defined so that you can store <code>weak_ptrs</code> in an ordered container, but that's all.

I am reading Scott Meyers "Effective C++" book. It was mentioned that there are <code>tr1::shared_ptr</code> and <code>tr1::weak_ptr</code> act like built-in pointers, but they keep track of how many <code>tr1::shared_ptrs</code> point to an object. 

This is known as reference counting. This works well in preventing resource leaks in acyclic data structures, but if two or more objects contain <code>tr1::shared_ptrs</code> such that a cycle is formed, the cycle may keep each other's reference count above zero, even when all external pointers to the cycle have been destroyed. 

That's where <code>tr1::weak_ptrs</code> come in.

My question is how cyclic data structures make the reference count above zero. I kindly request an example C++ program. How is the problem solved by <code>weak_ptrs</code>? (again, with example please).

shared_ptr and weak_ptr differences

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我正在读斯科特·迈尔斯的"Effective C++“一书。有人提到，tr1::shared_ptr和tr1::weak_ptr的作用类似于内置指针，但它们记录了有多少tr1::shared_ptrs指向一个对象。这就是所谓的引用计数。这可以很好地防止非循环数据结构中的资源泄漏，但如果两个或更多对象包含tr1::sha...

问shared_ptr和weak_ptr的区别
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问shared_ptr和weak_ptr的区别EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问shared_ptr和weak_ptr的区别
EN