Menu
I'm using enable_shared_from_this<Base> and then inherit from Base. When trying to use shared_from_this() in Derived's constructor (not initializer list), I get an exception. Turns out that the internal weak pointer is null and doesn't point to this at all. How can this happen? My other use case of exactly this works perfectly fine. I don't even know where to start. I looked down at the source code of enable_shared_from_this, and it looks to me like that pointer would always be nullptr.
865
std::enable_shared_from_this is a standard solution that enables a shared_ptr managed object to acquire a shared_ptr to itself on demand. A class T that publicly inherits an std::enable_shared_from_this<T> encapsulates a std::weak_ptr<T> to itself that can be converted to a std::shared_ptr<T> when needed.
std::enable_shared_from_this The class provides functionality that allows objects of derived classes to create instances of shared_ptr pointing to themselves and sharing ownership with existing shared_ptr objects.
A weak_ptr itself does not participate in the reference counting, and therefore, it cannot prevent the reference count from going to zero. However, you can use a weak_ptr to try to obtain a new copy of the shared_ptr with which it was initialized.
You can make a weak pointer from a shared pointer, just using assignment = e.g. bool release_channel(std::shared_ptr<abstract::channel> ch) { std::weak_ptr<abstract::channel> weak_ch = ch; //... }
You cannot call shared_from_this() in the object's constructor. shared_from_this() requires that the object is owned by at least one shared_ptr. An object cannot be owned by a shared_ptr before it is constructed.
I would guess that the internal weak pointer is set when a shared_ptr takes ownership of the object for the first time. Before that point, there is no reference count struct that the weak pointer can reference.
92
James McNellis's answer is right.
As for the explanation of the enable_shared_from_this template itself, which as you observe appears to do nothing, note 7 at the bottom of this page explains:
...the template
enable_shared_from_thisholds aweak_ptrobject that points to the derived object. There's a chicken-and-egg problem, though, about how to initialize thatweak_ptrobject when there is no correspondingshared_ptrobject. The implementation trick is that the constructors forshared_ptrknow aboutenable_shared_from_this, and set theweak_ptrobject during construction of ashared_ptrobject that owns a resource that hasenable_shared_from_thisas a public base class.
42
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
