51

In the book The C++ Standard Library at page 91 I have read this 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.

The relevant code snippet from the book is:

class Person : public std::enable_shared_from_this<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 Person? I think construction of 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 inherited from enable_shared_from_this, and if yes then initialize its internal weak_ptr.

Michael
  • 41,989
  • 11
  • 82
  • 128
Yola
  • 18,496
  • 11
  • 65
  • 106

1 Answers1

73

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—before there is any shared_ptr object to which enable_shared_from_this could bind.

Angew is no longer proud of SO
  • 167,307
  • 17
  • 350
  • 455
  • 1
    "...`enable_shared_from_this works` by initialising a hidden `weak_ptr` with a copy of the first `shared_ptr` which points to object `X`. " What procedure is responsible for initializing this hidden `weak_ptr`? How does it know what the "first" `shared_ptr` that points to `X` is? – ivme Jul 19 '17 at 21:17
  • 1
    @Chad See the notes here for some information: http://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr – Holt Jul 20 '17 at 09:55
  • 3
    Thanks @Holt. Looks like a constructor of `shared_ptr` is responsible for initializing the `weak_ptr`. Only those constructors that take a raw pointer (e.g. a pointer returned from a call to new) do the initialization. Copy constructors don't. Since only only the first `shared_ptr` to `X` should be constructed from a raw pointer (others are usually copy-constructed), the `weak_ptr` is initialized by the first `shared_ptr` to `X`. – ivme Jul 20 '17 at 15:22