Yola Yola - 3 months ago 6
C++ Question

Why shared_from_this can't be used in constructor from technical standpoint?

In the book at page 91 in chapter i have read this phrase about

shared_from_this()
:


The problem is that
shared_ptr
stores itself in a private member of
Person
’s base class,
enable_shared_from_this<>
, at the end of
the construction of the Person.


I don't understand two things here:


  1. who is this
    shared_ptr
    which stores itself?

  2. how he can store itself anywhere at the end of the construction of the Person? I think construction of the Person ends up with the last statement of its constructor which written by me.



I understand that there is weak_ptr which hasn't been initialized yet.

EDIT:
Thanks to Angew! shared_from_this will work only after first
shared_ptr
to Person was created. This
shared_ptr
will check if Person class inhereted from enable_shared_from_this, and if yes then initialize its internal
weak_ptr
.

Answer

The reason is simple: in object X, enable_shared_from_this works by initialising a hidden weak_ptr with a copy of the first shared_ptr which points to object X. However, for a shared_ptr to be able to point to X, X must already exist (it must be already constructed). Therefore, while the constructor of X is running, there is yet no shared_ptr which enable_shared_from_this could use.

Take this piece of code:

std::shared_ptr<Person> p(new Person());

Before the constructor of p (of the shared_ptr) is even called, its argument must be evaluated. That argument is the expression new Person(). Therefore, the constructor of Person runs before the constructor of p has even begun and before there is any shared_ptr object to which enable_shared_from_this could bind.

Comments