将成员函数存储在向量中并确保以后调用时对象仍然存在

Question

我有一个类X ，我想将成员函数bar传递给另一个类Y ，该类将把它存储在向量中并在其他时间调用它。

我了解我需要确保当Y调用函数时X仍然存在。 我怎么做？

在下面的示例中，我最初认为，如果我传递了shared_ptr来bar此操作，即，只要Y存在，那么X也会这样做，因为Y对其成员函数之一持有一个shared_ptr。

我现在很确定这个逻辑是不正确的。 有人可以启发我吗？

class Y {
  std::vector<std::shared_ptr<std::function<void()>>> m_v;
public:
  void foo(const std::shared_ptr<std::function<void()>>& callback) {
    m_v.push_back(callback);
  }

  void sometime_later() {
    // invoke call back function in vector
    // how do I ensure the object I want to call the function on still exists
  }
};

class X {
  Y& m_y;
public:
  X(Y& y) : m_y(y) {
    m_y.foo(std::make_shared<std::function<void()>>(std::bind(&X::bar, this)));
  }

  void bar() {
    // do some stuff
  }
};

Answer 1

这是将std::enable_shared_from_this与shared_ptr的别名构造函数结合使用的实现：

#include <vector>
#include <iostream>
#include <memory>
#include <functional>

class Y {
    std::vector<std::shared_ptr<std::function<void()>>> m_v;
public:
    void foo(const std::shared_ptr<std::function<void()>>& callback) {
      m_v.push_back(callback);
    }

    void sometime_later(){
        for (const auto& f: m_v) {
            (*f)();
        }
    }
};

class X : public std::enable_shared_from_this<X> {
  Y& m_y;
  std::function<void()> m_callback;
public:
  X(Y& y) : m_y(y), m_callback(std::bind(&X::bar, this)) {
  }

  void add()
  {
    m_y.foo(std::shared_ptr<std::function<void()>>{shared_from_this(), &m_callback});
    std::cout << shared_from_this().use_count() << "\n";
  }

  void bar() {
      std::cout << shared_from_this().use_count();
  }
};
int main(){

    Y y;
    {
        auto x = std::make_shared<X>(y);
        x->add();
    }
    y.sometime_later();
}

生活

Answer 2

我最终更改了设计以解决我的一生问题。

而不是声明一个向量，如下所示：

std::vector<std::shared_ptr<std::function<void()>>> 

然后在某个时间对存储的函数发出调用，我将其声明为：

std::vector<std::shared_ptr<X>> 

然后对对象X提出要求，以实现一个命名函数（在上面的示例中，它应该是bar ），然后在适当的时候调用它。 这样，我确保在调用回调函数时X存在。