Какая польза от `enable_shared_from_this`?

Это позволяет вам получить действительный экземпляр 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_ptr 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 *, этот внутренний weak_ptr T * инициализируется с refcount, равным 1. Новый shared_ptr в основном возвращается к этому weak_ptr.

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

Есть один случай, когда я нахожу enable_shared_from_this чрезвычайно полезным: Безопасность потоков при использовании асинхронного обратного вызова.

Представьте, что класс Client имеет член типа AsynchronousPeriodicTimer:

struct AsynchronousPeriodicTimer
{
    // call this periodically on some thread...
    void SetCallback(std::function<void(void)> callback); 
    void ClearCallback(); // clears the callback
}

struct Client
{
    Client(std::shared_ptr< AsynchronousPeriodicTimer> timer) 
        : _timer(timer)

    {
        _timer->SetCallback(
            [this]
            () 
            {
                assert(this); // what if 'this' is already dead because ~Client() has been called?
                std::cout << ++_counter << '\n';
            }
            );
    }
    ~Client()
    {
        // clearing the callback is not in sync with the timer, and can actually occur while the callback code is running
        _timer->ClearCallback();
    }
    int _counter = 0;
    std::shared_ptr< AsynchronousPeriodicTimer> _timer;
}

int main()
{
    auto timer = std::make_shared<AsynchronousPeriodicTimer>();
    {
        auto client = std::make_shared<Client>(timer);
        // .. some code    
        // client dies here, there is a race between the client callback and the client destructor           
    }
}

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

Решение: используйте enable_shared_from_this:

struct Client : std::enable_shared_from_this<Client>
{
Client(std::shared_ptr< AsynchronousPeriodicTimer> timer) 
    : _timer(timer)

    {

    }

    void Init()
    {
        auto captured_self = weak_from_this(); // weak_ptr to avoid cyclic references with shared_ptr

        _timer->SetCallback(
        [captured_self]
        () 
        {
            if (auto self = captured_self.lock())
            {
                // 'this' is guaranteed to be non-nullptr. we managed to promote captured_self to a shared_ptr           
                std::cout << ++self->_counter << '\n';
            }

        }
        );
    }
    ~Client()
    {
        _timer->ClearCallback();
    }
    int _counter = 0;
    std::shared_ptr< AsynchronousPeriodicTimer> _timer;
}

Метод Init отделен от конструктора, поскольку процесс инициализации enable_shared_from_this не завершается до выхода из конструктора. Отсюда дополнительный метод. Как правило, подписываться на асинхронный обратный вызов из конструктора небезопасно, поскольку обратный вызов может обращаться к неинициализированным полям.

Обратите внимание, что использование 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;
};