c++ - 如何在不是 shared_ptr 的成员中使用 shared_ptr？

Question

我正在处理几个类，我想知道如何在我的应用程序类中使用普通成员，而该成员需要使用 shared_from_this()？

这里有一些代码来阐明我的意思(见评论)

class Observable {
public:
    void addObserver(boost::shared_ptr<Observer> observer) {
        // add to a list
    }
};

class Observer {
public:
    virtual void onUpdate() = 0;
};

class MyObservableType : public Observable {
};

class ApplicationModel : public Observer {
private:
    MyObservableType mot;
public:
    void setup() {
    // how do I pass this as a boost::shared_ptr, as ApplicationModel is not 
    // a boost::shared_ptr in the Application class this using a call to 
    // "shared_from_this()" (and inheriting public shared_from_this<ApplicationModel>
        mot.addObserver([shared_from_this]) 
    }
};

class Application {
private:
    ApplicationModel model;
public:
    void setup() {
        model.
    }
};

Answer 1

对于这个问题，你有三种解决方案:

第一个解决方案:强制应用程序通过将其构造函数设为私有(private)来创建 shared_ptr。这是我建议对派生自 enable_shared_from_this

的任何类执行的操作

class ApplicationModel : public Observer, public boost::enable_shared_from_this<ApplicationModel> {
private:
    ApplicationModel(); // private constructor

    MyObservableType mot;
public:
    // an instance of this class can only be created using this function
    static boost::shared_ptr<ApplicationModel> buildApplicationModel() {
        return boost::make_shared<ApplicationModel>();
    }

    void setup() {
        mot.addObserver(shared_from_this()) ;
    }
};

第二种解决方案:改变你的代码设计。你不应该要求 ApplicationModel 将自己注册到 Observable，而应该自己做。这样 ApplicationModel 不会执行任何操作，但是如果它的所有者想要调用 addObservable，它必须创建一个 shared_ptr。这或多或少就是所谓的dependency injection。 .

class Application {
private:
    boost::shared_ptr<ApplicationModel> model;
    MyObservableType mot;
public:
    void setup() {
        model = boost::make_shared<ApplicationModel>();
        mot.addObserver(model);
    }
};

编辑:第三种解决方案:使用虚拟 shared_ptr，如下所示:

class ApplicationModel : public Observer {
private:
    boost::shared_ptr<ApplicationModel> myself;

    MyObservableType mot;

public:
    void setup() {
        mot.addObserver(myself) ;
    }

    ApplicationModel() {
        myself = boost::shared_ptr<ApplicationModel>(this, [](ApplicationModel*) {});
    }

    ~ApplicationModel() {
        mot.removeObserver(myself);
        assert(myself.unique());
    }
};

想法是为 this 创建一个 shared_ptr 并告诉 shared_ptr 不要调用析构函数(这里我使用一个空的 lambda 函数，但你可以很容易地创建一个内联函数结构)。这是一个 hack，你不应该这样做。