Why Can't You Use `shared_from_this()` in Constructors?

Understanding the Limitations of shared_from_this in Constructors

As stated in the excerpt from "The C Standard Library," shared_from_this() faces a technical limitation within constructors. To comprehend this concept, it's essential to delve into the inner workings of shared_from_this().

The Role of Weak Pointers in shared_from_this

shared_from_this() relies on an internal weak_ptr to maintain a weak reference to the created object. This weak pointer remains uninitialized until a strong shared_ptr (a shared_ptr that owns the object) is created for the object. Only after the first shared_ptr is instantiated can enable_shared_from_this, a base class of the object, access this shared_ptr and initialize the weak_ptr.

The Construction Timing Issue

This dependency on existing shared_ptrs poses a problem for constructors. When a constructor is being invoked, no shared_ptr pointing to the object being constructed exists yet. Therefore, during construction, enable_shared_from_this cannot initialize its weak_ptr, rendering shared_from_this() unusable within the constructor.

An Example for Clarification

Consider the following code snippet:

class Person : public std::enable_shared_from_this<person> {
   ...
};

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

In this example, the constructor of Person() runs before the constructor of the shared_ptr p. This means that during the Person() constructor, no shared_ptr pointing to the Person object exists, prohibiting enable_shared_from_this from initializing its weak_ptr and rendering shared_from_this() inaccessible within the constructor.

The above is the detailed content of Why Can't You Use `shared_from_this()` in Constructors?. For more information, please follow other related articles on the PHP Chinese website!