#include <iostream>#include <memory> class Good:public std::enable_shared_from_this<Good>{public:std::shared_ptr<Good> getptr(){return shared_from_this();}}; class Best:public std::enable_shared_from_this<Best>{struct Private{explicit Private()=default;}; public:// Constructor is only usable by this class    Best(Private){} // Everyone else has to use this factory function// Hence all Best objects will be contained in shared_ptrstaticstd::shared_ptr<Best> create(){returnstd::make_shared<Best>(Private());} std::shared_ptr<Best> getptr(){return shared_from_this();}}; struct Bad{std::shared_ptr<Bad> getptr(){returnstd::shared_ptr<Bad>(this);}    ~Bad(){std::cout<<"Bad::~Bad() called\n";}}; void testGood(){// Good: the two shared_ptr's share the same objectstd::shared_ptr<Good> good0=std::make_shared<Good>();std::shared_ptr<Good> good1= good0->getptr();std::cout<<"good1.use_count() = "<< good1.use_count()<<'\n';} void misuseGood(){// Bad: shared_from_this is called without having std::shared_ptr owning the callertry{        Good not_so_good;std::shared_ptr<Good> gp1= not_so_good.getptr();}catch(std::bad_weak_ptr& e){// undefined behavior (until C++17) and std::bad_weak_ptr thrown (since C++17)std::cout<< e.what()<<'\n';}} void testBest(){// Best: Same but cannot stack-allocate it:std::shared_ptr<Best> best0= Best::create();std::shared_ptr<Best> best1= best0->getptr();std::cout<<"best1.use_count() = "<< best1.use_count()<<'\n'; // Best stackBest; // <- Will not compile because Best::Best() is private.} void testBad(){// Bad, each shared_ptr thinks it is the only owner of the objectstd::shared_ptr<Bad> bad0=std::make_shared<Bad>();std::shared_ptr<Bad> bad1= bad0->getptr();std::cout<<"bad1.use_count() = "<< bad1.use_count()<<'\n';}// UB: double-delete of Bad int main(){    testGood();    misuseGood();     testBest();     testBad();}

good1.use_count() = 2bad_weak_ptrbest1.use_count() = 2bad1.use_count() = 1Bad::~Bad() calledBad::~Bad() called*** glibc detected *** ./test: double free or corruption