"Enable_shared_from_this" in faydası nedir?

Ben karşılaştım enable_shared_from_thisBoost.Asio örnekler okurken ve hala bu doğru nasıl kullanılması gerektiği için kayıp belgeleri okuduktan sonra. Birisi bana bir örnek verebilir mi ve bu sınıfı kullanırken bir açıklama mantıklı olabilir.

Sahip olduğunuz her şey için geçerli bir shared_ptrörnek thisalmanızı sağlar this. O olmadan, bir almanın yolu yoktur shared_ptriçin thiszaten bir üye olarak bir vardı sürece. Enable_shared_from_this için boost belgelerinden bu örnek :

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
}

Üye örneği olmasa bile yöntem f()geçerli bir değer döndürür shared_ptr. Bunu yapamayacağınızı unutmayın:

class Y: public enable_shared_from_this<Y>
{
public:

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

Bunun döndürdüğü paylaşılan işaretçinin "uygun" olandan farklı bir referans sayısı olacaktır ve bunlardan biri nesne silindiğinde sarkan bir referansı kaybedip tutacaktır.

enable_shared_from_thisC ++ 11 standardının bir parçası haline gelmiştir. Ayrıca buradan ve takviyeden de alabilirsiniz.

Zayıf işaretçiler hakkındaki Dr Dobbs makalesinden, bu örneğin anlaşılması daha kolay olduğunu düşünüyorum (kaynak: http://drdobbs.com/cpp/184402026 ):

... bunun gibi kodlar düzgün çalışmaz:

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

İki shared_ptrnesneden hiçbiri diğerini bilmez, bu yüzden her ikisi de yok edildiğinde kaynağı serbest bırakmaya çalışır. Bu genellikle sorunlara yol açar.

Benzer şekilde, bir üye işlevi shared_ptrçağrıldığı nesnenin sahibi olan bir nesneye ihtiyaç duyuyorsa, yalnızca anında bir nesne oluşturamaz:

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

Bu kod, daha ince bir formda olmasına rağmen, önceki örnekle aynı soruna sahiptir. İnşa edildiğinde, shared_ptr nesnesi sp1yeni tahsis edilen kaynağın sahibidir. Üye işlevinin içindeki kod S::dangerouso shared_ptrnesneyi bilmez , bu nedenle shared_ptrdöndürdüğü nesne birbirinden farklıdır sp1. Yeni shared_ptrnesneyi kopyalamak sp2yardımcı olmaz; ne zaman sp2kapsam dışına gider, bu kaynağı serbest ve ne zaman olacak sp1kapsam dışına gider, yine kaynak yayınlayacak.

Bu sorunu önlemenin yolu sınıf şablonunu kullanmaktır enable_shared_from_this. Şablon, yönetilen kaynağı tanımlayan sınıfın adı olan bir şablon türü bağımsız değişkeni alır. Bu sınıf, sırayla, şablondan alenen türetilmelidir; bunun gibi:

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

Bunu yaptığınızda, çağırdığınız nesnenin shared_from_thisbir shared_ptrnesneye ait olması gerektiğini unutmayın . Bu işe yaramaz:

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

İşte benim açıklamam, somun ve cıvata perspektifinden (en iyi cevap benimle 'tıklamadı'). * Bunun Visual Studio 2012 ile birlikte gelen shared_ptr ve enable_shared_from_this kaynağının araştırılmasının sonucu olduğunu unutmayın. Belki de diğer derleyiciler enable_shared_from_this'i farklı şekilde uygular ... *

enable_shared_from_this<T>weak_ptr<T>örneğinin T' bir gerçek referans sayısını ' içeren özel bir örnek ekler T.

Böylece, shared_ptr<T>yeni bir T * üzerine ilk oluşturduğunuzda , T * 'nin iç zayıf_ptr değeri 1 değerinde bir yeniden sayımla başlatılır. Yeni shared_ptrtemelde buna dayanır weak_ptr.

Tdaha sonra, metodlarını, arayabilir shared_from_thisbir örneği elde etmek için shared_ptr<T>bu aynı iç saklanan referans sayısı üzerine sırt . Bu şekilde, birbirlerini bilmeyen T*birden çok shared_ptrörneğe sahip olmak yerine her zaman ref sayımının depolandığı tek bir yeriniz olur ve her biri shared_ptr, ref sayımından Tve ref sayımından silmekten sorumlu olduklarını düşünür. -count sıfıra ulaşır.

Bir boost :: intrusive_ptr kullanmanın bu sorundan muzdarip olmadığını unutmayın. Bu genellikle bu sorunu aşmanın daha kolay bir yoludur.

C ++ 11 ve sonraki sürümlerde tamamen aynıdır: Size ham bir işaretçi verdiği thisiçin paylaşılan bir işaretçi olarak geri dönme özelliğini etkinleştirmektir this.

başka bir deyişle, kodu böyle çevirmenize izin verir

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

private:

    Node * m_parent = nullptr;
};           

bunun içine:

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

Diğer bir yolu bir eklemektir weak_ptr<Y> m_stubiçine üyesi class Y. Sonra yaz:

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

Türettiğiniz sınıfı değiştiremediğinizde kullanışlıdır (örneğin, başkalarının kitaplığını genişletme). Üyeyi başlatmayı unutmayın, örneğin m_stub = shared_ptr<Y>(this), bir kurucu sırasında bile geçerlidir.

Kalıtım hiyerarşisinde bunun gibi daha fazla taslak varsa, nesnenin yok edilmesini engellemez.

Düzenleme: Doğru kullanıcı nobar tarafından işaret gibi, atama bittiğinde ve geçici değişkenler yok edildiğinde kod Y nesnesini yok. Bu nedenle cevabım yanlış.