c++ - 事件发射器和成员方法自动注册为侦听器

这是一个有答案的问题，其目的是邀请读者提出自己的解决方案。
我非常确定，还有比我更聪明的方法，所以我想知道这些解决方案是什么。
请通过添加自己的答案来分享您的知识!!

目标是创建一个可用于调度一些事件的发射器类。

我想成为发射器的一个重要功能是易于使用的注册功能，可以将侦听器附加到发射器。

换句话说，我不想编写旨在将所有侦听器连接到发射器的函数/方法，因为它可能容易出错，而且我发现自己不止一次寻找由于缺少代码行而导致的错误因此(这行本来应该注册第N个侦听器)。

想象以下结构:

struct E1 { };

struct S {
    void receive(const E1 &ev) { /* do something */ }
};

我正在寻找的注册工具就是这样的解决方案，下面的代码行就足够了:

S s;
emitter.reg(s);

仅此而已，即使将来出现要求将另一个侦听器添加到struct S结构中的要求，例如:

struct E1 { };
struct E2 { };

struct S {
    void receive(const E1 &ev) { /* do something */ }
    void receive(const E2 &ev) { /* do something */ }
};

我怎么写这样的发射器？

最佳答案

首先包括:

#include <iostream>
#include <vector>
#include <type_traits>
#include <utility>
#include <functional>

我们使用void_t detection helper:

template<class ...>
using void_t = void;

我们定义一个特征来使用receive()检测void_t方法:

template<class C, class E, class X = void_t<>>
struct has_event_handler :
      std::false_type {};

template<class C, class E>
struct has_event_handler<C, E, void_t< decltype(
    std::declval<C>().receive(std::declval<const E>())
) >> : std::true_type {};

template<class C, class E>
constexpr bool has_event_handler_v = has_event_handler<C, E>::value;

使用此，我们可以定义发射器类。可变参数是它可以管理的事件类型:

template<class...> class Emitter;

// Recursive case:
template<class E, class... F>
class Emitter<E, F...> : Emitter<F...> {
public:
  // Register:
  template<class C>
  std::enable_if_t<!has_event_handler_v<C,E>> reg(C& callback) {
    Emitter<F...>::reg(callback);
  };
  template<class C>
  std::enable_if_t<has_event_handler_v<C,E>> reg(C& callback) {
    handlers_.push_back([&callback](E const& event) { return callback.receive(event); });
    Emitter<F...>::reg(callback);
  };
  void trigger(E const& event)
  {
    for (auto const& handler : handlers_)
      handler(event);
  }
  template<class G>
  void trigger(G const& event)
  {
    Emitter<F...>::trigger(event);
  }
private:
  std::vector<std::function<void(const E&)>> handlers_;
};

// Base case:
template<>
class Emitter<> {
public:
  template<class C>
  void reg(C& callback) {};
  template<class E>
  void trigger(E const& event)
  {
     static_assert(!std::is_same<E,E>::value,
       "Does not handle this type of event.");
  }
};

对于trigger()部分，另一种解决方案是使用std::enable_if_t<std::is_base_of_v<E, G>>。

我们可以将其用于:

// Events
struct E1 {};
struct E2 {};
struct E3 {};

// Handler
struct handler {
  void receive(const E1&)
  {
    std::cerr << "E1\n";
  }
  void receive(const E2&)
  {
    std::cerr << "E2\n";
  }
};

// Check the trait:
static_assert(has_event_handler_v<handler, E1>, "E1");
static_assert(has_event_handler_v<handler, E2>, "E2");
static_assert(!has_event_handler_v<handler, E3>, "E3");

int main()
{
  Emitter<E1, E2> emitter;
  handler h;
  emitter.reg(h);
  emitter.trigger(E1());
  emitter.trigger(E2());
}

注意:我使用了C++ 17的_v和_t变体，以使代码更短，但为了与C++ 11兼容，您可能需要使用struct版本(typename std::enable_if<foo>::type，std::is_base_of<B,D>::value等)。

更新:对于Emitter的递归情况，最好使用合成而不是继承:

template<class E, class... F>
class Emitter<E, F...> {
public:
  // Register:
  template<class C>
  std::enable_if_t<!has_event_handler_v<C,E>> reg(C& callback) {
    Emitter<F...>::reg(callback);
  };
  template<class C>
  std::enable_if_t<has_event_handler<C,E>::value> reg(C& callback) {
    handlers_.push_back([&callback](E const& event) { return callback.receive(event); });
    emitter_.reg(callback);
  };
  void trigger(E const& event)
  {
    for (auto const& handler : handlers_)
      handler(event);
  }
  template<class G>
  void trigger(G const& event)
  {
    emitter_.trigger(event);
  }
private:
  std::vector<std::function<void(const E&)>> handlers_;
  Emitter<F...> emitter_;
};