Creating a shared_ptr to this

No, creating a shared_ptr from the this pointer is almost always a mistake. Consider this example:

1#include <memory>
2
3class Example {
4public:
5  std::shared_ptr<Example> GetPtr() {
6    return std::shared_ptr<Example>(this);
7  }
8};
9
10int main() {
11  Example e;
12  auto ptr = e.GetPtr();
13}

The issue here is that the shared_ptr does not own the object it's pointing to. The object e is owned by the main function, not by any shared_ptr.

When the shared_ptr ptr is destroyed, it will attempt to delete the Example object. But this object was not dynamically allocated, and is not owned by the shared_ptr. This leads to undefined behavior, likely a crash.

The same issue occurs if you try to create a shared_ptr from the this pointer inside a member function.

The correct way to create a shared_ptr that owns an Example object is:

1#include <memory>
2
3class Example {
4 public:
5  static std::shared_ptr<Example> Create() {
6    return std::shared_ptr<Example>(
7      new Example());  
8  }
9
10 private:
11  Example() {}  // Private constructor
12};
13
14int main() { auto ptr = Example::Create(); }

Now, the shared_ptr returned by Create() has ownership of the dynamically allocated Example object. When ptr is destroyed, the Example object will be safely deleted.