`enable_shared_from_this`の有用性は何ですか？

enable_shared_from_thisBoost.Asioの例を読んでいる間、私は偶然見つけましたが、ドキュメントを読んだ後でも、これを正しく使用する方法に迷っています。誰かが私に例を挙げて、このクラスを使用するときの説明が理にかなっていますか？

持っているものがすべてあるshared_ptr場合にthis、有効なインスタンスをに取得できますthis。それがないと、すでにメンバーとして持っているのでなければ、shared_ptrto を取得する方法はありませんthis。enable_shared_from_thisのブーストのドキュメントからのこの例：

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 || q < p)); // p and q must share ownership
}

このメソッドf()は、shared_ptrメンバーインスタンスがなくても、有効なを返します。これを単純に行うことはできないことに注意してください。

class Y: public enable_shared_from_this<Y>
{
public:

    shared_ptr<Y> f()
    {
        return shared_ptr<Y>(this);
    }
}

これが返す共有ポインタは、「適切な」ものとは異なる参照カウントを持ち、オブジェクトが削除されると、そのうちの1つがぶら下がっている参照を失って保持することになります。

enable_shared_from_thisC ++ 11標準の一部となっています。ブーストだけでなく、そこからも取得できます。

ウィークポインターに関するドブス博士の記事から、この例は理解しやすいと思います（ソース：http : //drdobbs.com/cpp/184402026）：

...このようなコードは正しく機能しません：

int *ip = new int;
shared_ptr<int> sp1(ip);
shared_ptr<int> sp2(ip);

2つのshared_ptrオブジェクトはどちらも他方を認識していないため、破棄されると、両方がリソースを解放しようとします。それは通常問題を引き起こします。

同様に、メンバー関数がshared_ptr呼び出されているオブジェクトを所有するオブジェクトを必要とする場合、その場でオブジェクトを作成することはできません。

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;
}

このコードには、以前の例と同じ問題がありますが、形式はより微妙です。作成されると、shared_ptrオブジェクトsp1は新しく割り当てられたリソースを所有します。メンバー関数内のコードS::dangerousはそのshared_ptrオブジェクトを認識しないため、shared_ptr返されるオブジェクトはとは異なりますsp1。新しいshared_ptrオブジェクトをにコピーしsp2ても役に立ちません。ときsp2スコープ外になる、それがリソースを解放する、とするときsp1スコープ外になる、それが再びリソースを解放します。

この問題を回避する方法は、クラステンプレートを使用することenable_shared_from_thisです。テンプレートは、1つのテンプレートタイプ引数を取ります。これは、管理対象リソースを定義するクラスの名前です。そのクラスは、テンプレートからパブリックに派生する必要があります。このような：

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;
}

これを行うときは、呼び出すオブジェクトがオブジェクトshared_from_thisによって所有されている必要があることに注意してくださいshared_ptr。これは動作しません：

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

ここに私の説明があります。一概に言えません（上の答えは私と一緒に「クリック」しませんでした）。*これは、Visual Studio 2012に付属するshared_ptrおよびenable_shared_from_thisのソースを調査した結果であることに注意してください。おそらく他のコンパイラーは、enable_shared_from_thisを異なる方法で実装しています... *

enable_shared_from_this<T>のweak_ptr<T>インスタンスTの「1つの真の参照カウント」を保持するプライベートインスタンスを追加しますT。

したがって、最初にshared_ptr<T>新しいT *上にを作成すると、そのT *の内部weak_ptrはrefcountが1で初期化されます。新しいものはshared_ptr基本的にthisに戻りますweak_ptr。

T次いで、その方法では、呼び出すことができるshared_from_thisのインスタンスを取得するためにshared_ptr<T>、その同一の内部に記憶された参照カウントに背中を。このように、あなたは常に1位持っているT*の参照カウントが複数持つのではなく、保存されているshared_ptrお互いを知らないインスタンスを、それぞれが、彼らがいると思うshared_ptr参照カウントを担当しているTとするとき、その参照を削除します-countがゼロに達した。

boost :: intrusive_ptrを使用しても、この問題は発生しないことに注意してください。これは多くの場合、この問題を回避するためのより便利な方法です。

これはc ++ 11以降でもまったく同じです。生のポインタを提供するthisため、共有ポインタとして戻る機能を有効にしthisます。

つまり、このようにコードを回すことができます

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

private:

    Node * m_parent = nullptr;
};           

これに：

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;
};           

別の方法は、weak_ptr<Y> m_stubメンバーをに追加することclass Yです。次に書いてください：

shared_ptr<Y> Y::f()
{
    return m_stub.lock();
}

派生元のクラスを変更できない場合に役立ちます（他の人のライブラリを拡張するなど）。たとえばによってメンバーを初期化することを忘れないでくださいm_stub = shared_ptr<Y>(this)。それはコンストラクタの間でも有効です。

継承階層にこのようなスタブがさらに存在しても問題ありませんが、オブジェクトの破壊を防ぐことはできません。

編集：ユーザーnobarによって正しく指摘されているように、割り当てが完了して一時変数が破棄されると、コードはYオブジェクトを破棄します。したがって、私の答えは正しくありません。