使用 std::function 和 std::bind 来存储回调和处理对象删除。

Question

我想实现一个管理器，它使用 C++11 存储对多态类成员函数的回调。问题是我不确定如何处理成员所属的对象被删除或应该被删除的情况，我希望界面尽可能简单。

所以我想到了以下方法：存储一个 std::weak_ptr 到对象以及一个 std::function 到成员。

以下似乎有效：

class MyBase {
public:
    MyBase() {}
    virtual ~MyBase() {}
};
//--------------------------------------------------

class MyClass : public MyBase {
public:
    MyClass() : MyBase() {}
    void myDouble(double val) const { std::cout << "Value is: " << val << std::endl; }
};
//--------------------------------------------------

Class Manager {
public:
    void setFunction(std::weak_ptr<MyBase> base, std::function<void(double)> func) {
        m_function.first  = base;
        m_function.second = func;
    }
private:
    std::pair<std::weak_ptr<MyBase>, std::function<void(double)>> m_function;
};

要使用这个：

Manager db;
std::shared_ptr<MyClass> myClass = std::make_shared<MyClass>();
db.setFunction(myClass, std::bind(&MyClass::myDouble, myClass, std::placeholders::_1));

现在我想对用户隐藏std::bind部分，这样他只需要调用：

db.setFunction(myClass, &MyClass::myDouble);

所以我想在我的经理职能中几乎完成以下工作：

void setFunc2(std::weak_ptr<MyBase> base, std::function<void(double)> func) {
    m_function.first  = base;
    m_function.second = std::bind(func, base, std::placeholders::_1);
}

但是上面给出了错误：

error: no match for 'operator=' (operand types are 'std::function<void(double)>' and 
'std::_Bind_helper<false, std::function<void(double)>&, std::weak_ptr<MyBase>&, const std::_Placeholder<1>&>::type {aka std::_Bind<std::function<void(double)>(std::weak_ptr<MyBase>, std::_Placeholder<1>)>}')
         m_function.second = std::bind(func, base, std::placeholders::_1);

是否有更好的方法来做到这一点，或者是否有更好的方法让它发挥作用？

我注意到一些有趣的事情。如果我使用 std::shared_ptr，则 use_count() 会随着原始代码中对 std::bind 的调用而递增。因此我不能手动 reset/destroy 对象，除非我取消设置我的经理的成员。这种行为记录在哪里，我通常使用 cppreference?

我查看了以下问题，但似乎无法解决我的问题：How can I use polymorphism with std::function?

Answer 1

模板 setFunction 以便您可以接受指向派生成员的指针，而不必为 cv/ref 限定符的组合编写 12 个重载。

template<class D, class D2, class F>
void setFunction(const std::shared_ptr<D> &sp, F D2::* member) {
    // optionally static_assert that D2 is a base of D.
    m_function.first  = sp;
    m_function.second = std::bind(member, sp.get(), std::placeholders::_1);
}

显然，您需要确保在调用 m_function.second 之前 lock() m_function.first。

或者，只需使用同时捕获 weak_ptr 和成员函数指针的 lambda：

std::function<void(double)> m_function;

template<class D, class D2, class F>
void setFunction(const std::shared_ptr<D> &sp, F D2::* member) {
    std::weak_ptr<D> wp = sp;
    m_function = [wp, member](double d) {
        if(auto sp = wp.lock()){
             ((*sp).*member)(d);
        }
        else {
             // handle pointer no longer valid case.
        }
    };
}

Answer 2

我喜欢将 listener/broadcaster 与侦听器的实现分离。

这意味着我不能对听众提出要求。它不能要求以特定方式分配侦听器。

我发现的最简单的方法是让广播return一个令牌，其生命周期决定连接的生命周期。

using token = std::shared_ptr<void>;

template<class...Args>
struct broadcaster {
  using target = std::function<void(Args...)>;
  using wp_target = std::weak_ptr<target>;
  using sp_target = std::shared_ptr<target>;
  static sp_target wrap_target( target t ) {
    return std::make_shared<target>(std::move(t));
  };

  token start_to_listen( target f ) {
    auto t = wrap_target(std::move(f));
    targets.push_back(t);
    return t;
  }
  void broadcast( Args... args ) {
    targets.erase(
      std::remove_if( targets.begin(), targets.end(),
        [&]( wp_target t )->bool { return t.expired(); }
      ),
      targets.end()
    );
    auto targets_copy = targets; // in case targets is modified by listeners
    for (auto wp : targets_copy) {
      if (auto sp = wp.lock()) {
        (*sp)(args...);
      }
    }
  }
  std::vector<wp_target> targets;
};

这迫使注册听众的人保持 std::shared_ptr<void>。

我们甚至可以让它更漂亮，销毁最后一个 shared_ptr<void> 实际上会立即从列表中删除侦听器。但是根据我的经验，上面的惰性注销似乎工作得相当好，而且让它对多线程友好也相对容易。（一个严重的问题是当广播事件从监听器列表中删除或添加内容时会发生什么：调整上面的内容以使其工作非常容易，规则是广播时添加的监听器不会收到广播，而监听器在广播期间被删除广播没有得到广播。在广播期间并发移除的听众可以在我的大多数实现中得到广播...避免这种情况会很昂贵。）

我们可以用不同的方式解耦它。收听者可以将 std::function 和 std::weak_ptr 分别传递给广播者，广播者存储两者并仅在 std::weak_ptr 有效时才调用 std::function。

Answer 3

我喜欢 Yakk 的方法。这是修复了一些编译问题的更新版本（例如，无法命名函数 'register'）。它还为客户端添加了一个 rm_callback 方法来轻松删除他们的注册，而无需强制他们的注册令牌超出范围或了解内部结构。我不喜欢每次广播事件时都扫描列表，所以我在执行清理任务的共享指针上添加了一个删除器。所有引入的新错误或低效率都是我的。警报reader 应该注意在广播时修改列表时的线程问题...

using token = std::shared_ptr<void>;
template<class...Args>
struct broadcaster {
    using target = std::function<void(Args...)>;
    using wp_target = std::weak_ptr<target>;
    using sp_target = std::shared_ptr<target>;

    token add_callback(target f) {
        sp_target t(new target(std::move(f)), [&](target*obj) { delete obj; cleanup(); });
        targets.push_back(t);
        return t;
    }

    static void rm_callback(token& t)
    {
        t.reset();
    }

    void cleanup()
    {
        targets.erase(
            std::remove_if(targets.begin(), targets.end(),
                [](wp_target t) { return t.expired(); }
            ),
            targets.end()
        );
    }

    void broadcast(Args... args) {
        for (auto wp : targets) {
            if (auto sp = wp.lock()) {
                (*sp)(args...);
            }
        }
    }

    std::vector<wp_target> targets;
};

// declare event taking a string arg
broadcaster<std::string> myEvent;

使用 std::function 和 std::bind 来存储回调和处理对象删除。

Using std::function and std::bind to store callback and handle object deletion.

c++

stdbind

c++11

std-function