blocks|key|1375170|text|它使您能够将一个有效的shared_ptr实例转换为this，而您所拥有的只有this。如果没有它，您将无法获得this的shared_ptr，除非您已经拥有一个成员身份。boost+documentation+for+enable_shared_from_this中的此示例|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1375171|class+Y:+public+enable_shared_from_this<Y>
{
public:

++++shared_ptr<Y>+f()
++++{
++++++++return+shared_from_this();
++++}
}

int+main()
{
++++shared_ptr<Y>+p(new+Y);
++++shared_ptr<Y>+q+=+p->f();
++++assert(p+==+q);
++++assert(!(p+<+q+%7C%7C+q+<+p));+//+p+and+q+must+share+ownership
}|code-block|syntax|javascript|1375172|即使方法f()没有成员实例，它也会返回一个有效的shared_ptr。请注意，您不能简单地这样做：|1375173|class+Y:+public+enable_shared_from_this<Y>
{
public:

++++shared_ptr<Y>+f()
++++{
++++++++return+shared_ptr<Y>(this);
++++}
}|1375174|这个返回的共享指针将有一个与“正确的”不同的引用计数，当对象被删除时，其中一个将丢失并持有一个悬空的引用。|1375175|enable_shared_from_this已成为C%2B%2B+11标准的一部分。你也可以从那里获得它，也可以从boost获得。|1375176|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_38_0/libs/smart_ptr/enable_shared_from_this.html^0|B|A|Q|4|13|4|1K|4|1P|A|2E|1B|0|0|0|4|3|O|A|0|0|0|0|N|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|F|3|G|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1L|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

It enables you to get a valid <code>shared_ptr</code> instance to <code>this</code>, when all you have is <code>this</code>. Without it, you would have no way of getting a <code>shared_ptr</code> to <code>this</code>, unless you already had one as a member. This example from the <a href="http://www.boost.org/doc/libs/1_38_0/libs/smart_ptr/enable_shared_from_this.html" rel="noreferrer">boost documentation for enable_shared_from_this</a>:

<pre><code>class Y: public enable_shared_from_this&lt;Y&gt;
{
public:

 shared_ptr&lt;Y&gt; f()
 {
 return shared_from_this();
 }
}

int main()
{
 shared_ptr&lt;Y&gt; p(new Y);
 shared_ptr&lt;Y&gt; q = p-&gt;f();
 assert(p == q);
 assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
}
</code></pre>

The method <code>f()</code> returns a valid <code>shared_ptr</code>, even though it had no member instance. Note that you cannot simply do this:

<pre><code>class Y: public enable_shared_from_this&lt;Y&gt;
{
public:

 shared_ptr&lt;Y&gt; f()
 {
 return shared_ptr&lt;Y&gt;(this);
 }
}
</code></pre>

The shared pointer that this returned will have a different reference count from the "proper" one, and one of them will end up losing and holding a dangling reference when the object is deleted.

<code>enable_shared_from_this</code> has become part of C++ 11 standard. You can also get it from there as well as from boost.

blocks|key|1590466|text|从Dobbs博士关于弱指针的文章中，我认为这个例子更容易理解(来源：http://drdobbs.com/cpp/184402026)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1590467|像这样的...code将无法正常工作：|1590468|int+*ip+=+new+int;
shared_ptr<int>+sp1(ip);
shared_ptr<int>+sp2(ip);|code-block|syntax|javascript|1590469|这两个shared_ptr对象都不知道对方，所以当它们被销毁时，它们都会尝试释放资源。这通常会导致问题。|style|CODE|1590470|类似地，如果一个成员函数需要一个拥有被调用对象的shared_ptr对象，它不能只动态创建一个对象：|1590471|struct+S
{
++shared_ptr<S>+dangerous()
++{
+++++return+shared_ptr<S>(this);+++//+don't+do+this!
++}
};

int+main()
{
+++shared_ptr<S>+sp1(new+S);
+++shared_ptr<S>+sp2+=+sp1->dangerous();
+++return+0;
}|1590472|这段代码与前面的示例具有相同的问题，尽管形式更为微妙。在构造时，shared_ptr+object+sp1拥有新分配的资源。成员函数S::dangerous中的代码不知道该shared_ptr对象，因此它返回的shared_ptr对象与sp1不同。将新的shared_ptr对象复制到sp2没有任何帮助；当sp2超出作用域时，它将释放资源，而当sp1超出作用域时，它将再次释放资源。|1590473|避免这个问题的方法是使用类模板enable_shared_from_this。该模板接受一个模板类型参数，该参数是定义托管资源的类的名称。反过来，该类必须从模板中公开派生；如下所示：|1590474|struct+S+:+enable_shared_from_this<S>
{
++shared_ptr<S>+not_dangerous()
++{
++++return+shared_from_this();
++}
};

int+main()
{
+++shared_ptr<S>+sp1(new+S);
+++shared_ptr<S>+sp2+=+sp1->not_dangerous();
+++return+0;
}|1590475|执行此操作时，请记住调用shared_from_this的对象必须属于shared_ptr对象。这是行不通的：|1590476|int+main()
{
+++S+*p+=+new+S;
+++shared_ptr<S>+sp2+=+p->not_dangerous();+++++//+don't+do+this
}|1590477|entityMap|0|LINK|mutability|MUTABLE|url|http://drdobbs.com/cpp/184402026^0|Y|W|0|0|0|0|3|A|0|O|A|0|0|W|9|1E|3|1U|C|2E|A|2X|A|3A|3|3J|A|3Y|3|49|3|4S|3|0|F|N|0|0|C|G|Z|A|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1F|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1G|8|@$A|1H|B|1I|M|N]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1J|8|@$A|1K|B|1L|M|N]]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1M|8|@]|9|@]|C|$I|J]]|$1|S|3|T|5|6|7|1N|8|@$A|1O|B|1P|M|N]|$A|1Q|B|1R|M|N]|$A|1S|B|1T|M|N]|$A|1U|B|1V|M|N]|$A|1W|B|1X|M|N]|$A|1Y|B|1Z|M|N]|$A|20|B|21|M|N]|$A|22|B|23|M|N]|$A|24|B|25|M|N]|$A|26|B|27|M|N]]|9|@]|C|$]]|$1|U|3|V|5|6|7|28|8|@$A|29|B|2A|M|N]]|9|@]|C|$]]|$1|W|3|X|5|H|7|2B|8|@]|9|@]|C|$I|J]]|$1|Y|3|Z|5|6|7|2C|8|@$A|2D|B|2E|M|N]|$A|2F|B|2G|M|N]]|9|@]|C|$]]|$1|10|3|11|5|H|7|2H|8|@]|9|@]|C|$I|J]]|$1|12|3|-4|5|6|7|2I|8|@]|9|@]|C|$]]]|13|$14|$5|15|16|17|C|$18|19]]]]

from Dr Dobbs article on weak pointers, I think this example is easier to understand (source: <a href="http://drdobbs.com/cpp/184402026" rel="noreferrer">http://drdobbs.com/cpp/184402026</a>):

...code like this won't work correctly:

<pre><code>int *ip = new int;
shared_ptr&lt;int&gt; sp1(ip);
shared_ptr&lt;int&gt; sp2(ip);
</code></pre>

Neither of the two <code>shared_ptr</code> objects knows about the other, so both will try to release the resource when they are destroyed. That usually leads to problems. 

Similarly, if a member function needs a <code>shared_ptr</code> object that owns the object that it's being called on, it can't just create an object on the fly:

<pre><code>struct S
{
 shared_ptr&lt;S&gt; dangerous()
 {
 return shared_ptr&lt;S&gt;(this); // don't do this!
 }
};

int main()
{
 shared_ptr&lt;S&gt; sp1(new S);
 shared_ptr&lt;S&gt; sp2 = sp1-&gt;dangerous();
 return 0;
}
</code></pre>

This code has the same problem as the earlier example, although in a more subtle form. When it is constructed, the <code>shared_pt</code>r object <code>sp1</code> owns the newly allocated resource. The code inside the member function <code>S::dangerous</code> doesn't know about that <code>shared_ptr</code> object, so the <code>shared_ptr</code> object that it returns is distinct from <code>sp1</code>. Copying the new <code>shared_ptr</code> object to <code>sp2</code> doesn't help; when <code>sp2</code> goes out of scope, it will release the resource, and when <code>sp1</code> goes out of scope, it will release the resource again.

The way to avoid this problem is to use the class template <code>enable_shared_from_this</code>. The template takes one template type argument, which is the name of the class that defines the managed resource. That class must, in turn, be derived publicly from the template; like this:

<pre><code>struct S : enable_shared_from_this&lt;S&gt;
{
 shared_ptr&lt;S&gt; not_dangerous()
 {
 return shared_from_this();
 }
};

int main()
{
 shared_ptr&lt;S&gt; sp1(new S);
 shared_ptr&lt;S&gt; sp2 = sp1-&gt;not_dangerous();
 return 0;
}
</code></pre>

When you do this, keep in mind that the object on which you call <code>shared_from_this</code> must be owned by a <code>shared_ptr</code> object. This won't work:

<pre><code>int main()
{
 S *p = new S;
 shared_ptr&lt;S&gt; sp2 = p-&gt;not_dangerous(); // don't do this
}
</code></pre>

blocks|key|1590523|text|请注意，使用boost::intrusive_ptr不会遇到此问题。这通常是解决这个问题的一种更方便的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1590524|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|$]]

Note that using a boost::intrusive_ptr does not suffer from this problem.
This is often a more convenient way to get around this issue.

blocks|key|1375340|text|在c%2B%2B11和更高版本中完全相同:它允许将this作为共享指针返回，因为this提供了一个原始指针。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1375341|换句话说，它允许您像这样转换代码|1375342|class+Node+{
public:
++++Node*+getParent+const()+{
++++++++if+(m_parent)+{
++++++++++++return+m_parent;
++++++++}+else+{
++++++++++++return+this;
++++++++}
++++}

private:

++++Node+*+m_parent+=+nullptr;
};+++++++++++|code-block|syntax|javascript|1375343|如下所示：|1375344|class+Node+:+std::enable_shared_from_this<Node>+{
public:
++++std::shared_ptr<Node>+getParent+const()+{
++++++++std::shared_ptr<Node>+parent+=+m_parent.lock();
++++++++if+(parent)+{
++++++++++++return+parent;
++++++++}+else+{
++++++++++++return+shared_from_this();
++++++++}
++++}

private:

++++std::weak_ptr<Node>+m_parent;
};+++++++++++|1375345|entityMap^0|L|4|10|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

It's exactly the same in c++11 and later: It is to enable the ability to return <code>this</code> as a shared pointer since <code>this</code> gives you a raw pointer.

in other word, it allows you to turn code like this

<pre><code>class Node {
public:
 Node* getParent const() {
 if (m_parent) {
 return m_parent;
 } else {
 return this;
 }
 }

private:

 Node * m_parent = nullptr;
}; 
</code></pre>

into this:

<pre><code>class Node : std::enable_shared_from_this&lt;Node&gt; {
public:
 std::shared_ptr&lt;Node&gt; getParent const() {
 std::shared_ptr&lt;Node&gt; parent = m_parent.lock();
 if (parent) {
 return parent;
 } else {
 return shared_from_this();
 }
 }

private:

 std::weak_ptr&lt;Node&gt; m_parent;
}; 
</code></pre>

I ran across <code>enable_shared_from_this</code> while reading the Boost.Asio examples and after reading the documentation I am still lost for how this should correctly be used. Can someone please give me an example and explanation of when using this class makes sense.

What is the usefulness of `enable_shared_from_this`?

我在阅读Boost.Asio示例时遇到了enable_shared_from_this，在阅读了文档之后，我仍然不知道应该如何正确使用它。谁能给我举个例子，解释一下什么时候使用这个类是有意义的。

问`enable_shared_from_this`的用处是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问`enable_shared_from_this`的用处是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问`enable_shared_from_this`的用处是什么？
EN