Understanding the Limitations of shared_from_this() in Constructors
The concept of shared_from_this() may seem convenient for establishing shared pointers to an object from within its constructor. However, it poses a technical limitation that prevents its direct use. To understand the issue, let's explore the underlying mechanism:
The Puzzle: Self-Storing shared_ptr and Construction Timing
According to the book reference, the shared_ptr is stored within a private member of enable_shared_from_this<> within the Person's base class. The confusion arises from two key points:
Why is shared_from_this() Restricted in Constructors?
The limitation of shared_from_this() in constructors is due to the sequential nature of construction. While the constructor of Person is executing, there is no shared_ptr yet created that could point to the Person object. The shared_ptr is created externally, after Person's construction.
Underlying Mechanism of shared_from_this()
enable_shared_from_this<> provides a way to establish a hidden weak_ptr within the object. This weak_ptr is then used by the first shared_ptr created outside the object to initialize itself. However, this initialization only occurs when a shared_ptr is created externally.
Conclusion
While shared_from_this() enables the creation of shared pointers to objects from outside their class, its use within the constructor is limited by the construction sequence. The shared_ptr must be created externally, after the object's construction is complete. This is a technical limitation that ensures the correct functioning of shared pointers.
The above is the detailed content of Why Can't `shared_from_this()` Be Used Directly in Constructors?. For more information, please follow other related articles on the PHP Chinese website!