c++ shared_ptr储存this指针多次析构问题之enable_shared_from_this解决方案

        #include <iostream>
#include <memory>
#include <cassert>
/*
        //this //调用了两次析构函数,
        ParentPtr p(this);
        //智能指针出了作用域后就delete this ,析构了
        //所以错了,为了解决这个问题,就需要自身的类继承于　std::enable_shared_from_this<Type>
        //将ParentPtr p(this) 换成, shared_from_this();
 
 */
class Parent;
typedef std::shared_ptr<Parent> ParentPtr;
typedef std::weak_ptr<Parent> WeakParentPtr;

class Child : public std::enable_shared_from_this<Child> {
    public:
        WeakParentPtr father;
//      ParentPtr father;
        ~Child();
        Child();
        void checkRelation();
};

typedef std::shared_ptr<Child> ChildPtr;
typedef std::weak_ptr<Child> WeakChildPtr;

class Parent : public std::enable_shared_from_this<Parent> {
    public:
        WeakChildPtr son;
//      ChildPtr son;
        ~Parent();
        Parent();
        void checkRelation();
};

void handleChildAndParentRef(const Parent &p, const Child &c) {
    if(c.father.lock().get() == &p && p.son.lock().get() == &c) {
        std::cout << "right relation" << std::endl; 
    }else {
        std::cout << "oop!!!!!!" << std::endl;
    }
}
void handleChildAndParent(const ParentPtr &p, const ChildPtr &c) {
    assert(c);
    assert(p);
    if(c->father.lock() == p && p->son.lock() == c) {
        std::cout << "right relation" << std::endl; 
    }else {
        std::cout << "oop!!!!!!" << std::endl;
    }
}
Child::Child() { std::cout << "hello child" << std::endl; }
Child::~Child() { std::cout << "bye child" << std::endl; }
Parent::Parent() { std::cout << "hello parent" << std::endl; }
Parent::~Parent() { std::cout << "bye parent" << std::endl; }

void Parent::checkRelation() {
    auto ps = son.lock();
    if(ps) {
        //this //调用了两次析构函数,
//      ParentPtr p(this);
        //handleChildAndParent(p, ps);  

        //智能指针出了作用域后就delete this ,析构了
        //所以错了,为了解决这个问题,就需要自身的类继承于　std::enable_shared_from_this<Type>
        //将ParentPtr p(this) 这种错误形式换成, shared_from_this()
        handleChildAndParent(shared_from_this(), ps);   
    }
        std::cout << "after call checkRelation" << std::endl;
}

void Child::checkRelation() {
    
}
void testParentAndChild() {
    //若Parent 继承于 std::enable_shared_from_this<Type>
    //则 Parent pp; 这种静态的就不推荐
    ParentPtr p(new Parent());
    ChildPtr c(new Child());
    p->son = c;
    c->father = p;
    p->checkRelation();
}

static void interfaceOfSharedPtr();
static void sharedPtrWithWeakPtr();
static void uniquePtr();

int main(void) {
    testParentAndChild();   
    return 0 ;
}

    

原文：https://www.cnblogs.com/lyxf/p/12358294.html