c++ - std::function 在 C++ 中接受不同的函数签名

Question

我正在尝试创建一个类似于 C# 系统的 C++ 事件系统。我需要能够存储任何类型的函数并在适当的时间使用正确的参数调用它们。

我能得到的最接近的是 std::function、bind 和占位符，但这是我的问题。

void Func()
{
    std::cout << "Notified" << std::endl;
}

void FuncWithParam(const std::string& str)
{
    std::cout << str << std::endl;
}

std::function<void()> fn = std::bind(Func); // this works

std::function<void()> fn = std::bind(FuncWithParam, "Hello there"); // this works also

std::function<void()> fn = std::bind(FuncWithParam, _1); // but this doesn't

是否真的可以在单个 std::function 中存储任何类型的签名？还是我必须求助于更复杂的解决方案。

Answer 1

这是一个简单的 C++ 广播器:

using token = std::shared_ptr<void>;

template<class...Ts>
struct broadcaster {
  using listen = std::function<void(Ts...)>;
  using sp_listen = std::shared_ptr<listen>;
  using wp_listen = std::weak_ptr<listen>;

  token attach( listen l ) {
    return attach( std::make_shared<listen>(std::move(l)) );
  }
  token attach( sp_listen sp ) {
    listeners.push_back(sp);
    return sp;
  }
  void operator()(Ts...ts)const {
    listeners.erase(
      std::remove_if( begin(listeners), end(listeners),
        [](auto&& wp){return !(bool)wp.lock();}
      ),
      end(listeners)
    );
    auto tmp = listeners;
    for (auto&& l : tmp) {
      if (auto pf = l.lock()) {
        (*pf)(ts...);
      }
    }
  }
private:
  mutable std::vector<wp_listen> listeners;
};

要收听它，您可以.attach 并向它传递一个要调用的函数。 attach 返回一个 token，只要该 token (或其拷贝)继续存在，就会调用该函数。

要调用消息，您可以在 broadcaster 上调用 ()。

下次您调用广播者时，死回调的内存将被回收；间接拥有的资源清理得更快。

如果您在当前广播时注册一个监听器，它将不会获得当前广播。

您可以添加一个 std::mutex 以使其可同时从多个线程使用，或外部同步。如果您在内部同步，我不会在您运行 () 中的 for(auto&& 循环时保持互斥量以避免重入问题。

使用示例:

struct location {
  int x, y;
};
struct button {
  broadcaster< location > mouse_click;
  broadcaster<> mouse_enter;
  broadcaster<> mouse_leave;
};

struct dancer {
  std::vector<token> listen_tokens;
  dancer( button& b ) {
    listen_tokens.push_back( b.mouse_enter.attach([this]{ dance(); } ) );
    listen_tokens.push_back( b.mouse_leave.attach([this]{ end_dance(); } ) );
    listen_tokens.push_back( b.mouse_click.attach(
      [this](location l){
        pose(l.x, l.y);
      }
    ) );
  }
  void dance() const {
    std::cout << "start dancing\n";
  }
  void pose( int x, int y ) const {
    std::cout << "struck a pose at " << x << ", " << y << "\n";
  }
  void end_dance() const {
    std::cout << "end dancing\n";
  }
};

请注意，没有使用virtual 方法。唯一的多态性是基于 std::function 的类型删除。

监听对象必须明确地跟踪它们要监听的生命周期(通过保持 token 事件)，并且如果它们希望能够注销到特定的广播者，它们必须保持该关联他们自己。

如果广播者先离开，没有问题。如果听众离开，只要他们的 token 先于他们，一切都可以。附加确实会导致动态分配存储 token (并移动到监听器的拷贝中)，但只有一个。

这与您在 C# 中使用的方法不同，既因为它依赖于 RAII，也因为它的核心不是 OO，但仍然是多态的。