В чем полезность `enable_shared_from_this`?

Я наткнулся enable_shared_from_thisпри чтении примеров Boost.Asio и после прочтения документации я все еще теряюсь в том, как это следует правильно использовать. Может ли кто-нибудь дать мне пример и объяснение того, когда использование этого класса имеет смысл.

Это позволяет вам получить действительный shared_ptrэкземпляр this, когда все, что у вас есть this. Без него вы не имели бы никакого способа получать shared_ptrк 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);
    }
}

Общий указатель, который он вернул, будет иметь счетчик ссылок, отличный от «правильного», и один из них потеряет и удержит висячую ссылку при удалении объекта.

enable_shared_from_thisстал частью стандарта C ++ 11. Вы также можете получить его оттуда, а также от повышения.

из статьи доктора Доббса о слабых указателях, я думаю, этот пример легче понять (источник: http://drdobbs.com/cpp/184402026 ):

... такой код не будет работать правильно:

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

Ни один из двух 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_ptобъект r sp1владеет вновь выделенным ресурсом. Код внутри функции-члена S::dangerousне знает об этом shared_ptrобъекте, поэтому shared_ptrвозвращаемый объект отличается от него sp1. Копирование нового shared_ptrобъекта в sp2не помогает; когда sp2выходит из области действия, он освобождает ресурс, а когда sp1выходит из области действия, он освобождает ресурс снова.

Чтобы избежать этой проблемы, используйте шаблон класса enable_shared_from_this. Шаблон принимает один аргумент типа шаблона, который является именем класса, который определяет управляемый ресурс. Этот класс, в свою очередь, должен быть публично получен из шаблона; как это:

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
}

Вот мое объяснение с точки зрения гайки и болты (верхний ответ не «щелкнул» со мной). * Обратите внимание, что это результат изучения источника для shared_ptr и enable_shared_from_this, который поставляется с Visual Studio 2012. Возможно, другие компиляторы реализуют enable_shared_from_this по-другому ... *

enable_shared_from_this<T>добавляет частный weak_ptr<T>экземпляр, в Tкотором хранится « один истинный счетчик ссылок » для экземпляра T.

Таким образом, когда вы впервые создаете shared_ptr<T>на новый T *, внутренний слабый_птр этого T * инициализируется с повторным счетом 1. Новое в shared_ptrосновном возвращается к этому weak_ptr.

Tзатем может в своих методах вызывать shared_from_thisдля получения экземпляра этого объекта shared_ptr<T>тот же внутренний счетчик ссылок . Таким образом, у вас всегда есть одно место, где T*хранится ref-count, а не несколько shared_ptrэкземпляров, которые не знают друг о друге, и каждый думает, shared_ptrчто именно он отвечает за подсчет Tи удаление его, когда их ref Счет достигает нуля.

Обратите внимание, что использование 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, когда присваивание будет завершено, а временные переменные уничтожены. Поэтому мой ответ неверен.