如何获取 std::function 参数的类型

Question

我正在尝试在地图中存储事件的回调。由于每个类应该有一个回调，我目前使用typeid(<eventClass>).name() 作为键，使用 std::function 作为值。我遇到的问题是在注册回调时，我需要事件的类型，而我想出的唯一可能的解决方案是将事件类作为模板参数传递。这是一个我想“优化”的工作示例：

std::map<Widget *, std::map<std::string, std::function<void(Widget*, Event &)>>> handlers;

template<typename T, std::enable_if_t<std::is_base_of_v<Event, T>, bool> = true>
void setCallback(Widget *obj, const std::function<void(Widget *, T &event)> &callback) {
    handlers[obj].insert(std::make_pair(typeid(T).name(), reinterpret_cast<const std::function<void(Widget *, Event &)> &>(callback)));
}

void fire(Widget *obj, Event &event) {
    auto it = handlers.find(obj);
    if (it != handlers.end()) {
        auto it2 = it->second.find(typeid(event).name());
        if (it2 != it->second.end()) {
            it2->second(obj, event);
            return; // debug
        }
    }

    printf("No handler found!\n"); // debug
}

由于setCallback函数中的模板参数，使用方法如下：

void callback(Widget *, BarEvent &barEvent) {
    printf("%d\n", barEvent.getFoo());
}

void callback2(Widget *, FooEvent &fooEvent) {
    printf("%d\n", fooEvent.getFoo());
}

int main() {

    Widget *obj = new Widget();
    Widget *obj2 = new Widget();
    setCallback<BarEvent>(obj, callback);
    setCallback<FooEvent>(obj2, callback2);

    BarEvent event;
    fire(obj, event);
    fire(obj2, event);

    FooEvent event2;
    fire(obj, event2);
    fire(obj2, event2);

    delete obj;
    delete obj2;
    return 0;
}

在设置回调时必须传递模板参数很容易出错并且只是“开销”，因为事件类已经在回调中。有没有办法在setCallback函数中获取callback参数的第二个参数的类型？

如果可能，函数应该如下所示：

void setCallback(Widget *widget, const std::function<void(Widget *, Event &)> &callback) {
    handlers[widget].insert(std::make_pair(typeid(<2nd param of callback>).name(), callback));
}

Answer 1

这里有一些代码不使用reinterpret_cast 并自动进行扣除（在许多但不是所有情况下）。代码完整且可运行，但被纯文本中断（比等宽 cmets 更具可读性）。

  #include <vector>
  #include <map>
  #include <typeinfo>
  #include <typeindex>
  #include <iostream>
  #include <type_traits>
  
  struct Event
  {
      virtual ~Event() = default;
  };
  
  struct FooEvent : Event {};
  struct BarEvent : Event {};
  
  template <typename>
  struct extract_second_argument;

下一部分是我们从普通函数和std::function 对象中提取第二个参数类型的管道。请注意，这些并不是所有可以调用的东西。该机制不适用于 lambda 和其他函数对象，或指向成员的指针。

  template <typename A, typename B, typename C, typename ... X>
  struct extract_second_argument<A (*)(B, C, X...)>
  {
      using type = std::remove_reference_t<C>;
  };
  
  template <typename A, typename B, typename C, typename ... X>
  struct extract_second_argument<std::function<A(B, C, X...)>>
  {
      using type = std::remove_reference_t<C>;
  };
  
  template <typename T>
  using extract_second_argument_t = typename extract_second_argument<T>::type;

这是我们的（简化的）小部件。它包含的不是一个，而是两个不同的回调容器！选择你喜欢的那个。请注意，即使速度较慢（执行更多动态转换），普通向量也可能是首选，因为它与基于映射的向量不同，支持回调层次结构。您可以为 Parent 事件和 Child 事件添加回调，如果 Child 被触发，两个回调都将被调用。你是否需要这个是你的决定。两种机制都允许每个事件类型有很多回调（这在大多数情况下是可取的，但如果不是您喜欢的茶，只需使用普通映射而不是多映射）。

  struct Widget {
      using Callback = std::function<void(Widget&, Event&)>;
      using CallbackList = std::vector<Callback>;
      using CallbackMap = std::multimap<std::type_index, Callback>;
  
      CallbackList callbacks;
      CallbackMap callbacks2;

这会添加任何性质的回调（普通函数、std::function、lambda...），但不会推导参数类型。

      template <typename EV>
      void addCallbackImpl(std::function<void(Widget&, EV&)> cb)
      {

这个包装器是机器的核心。请注意，它使用了Event 的多态特性。

          auto wrapper = [=](Widget& w, Event& ev) {
              auto* realEv = dynamic_cast<EV*>(&ev);
              if (realEv) cb(w, *realEv);
          };

我们的两个回调容器（你只需要一个）。

          callbacks.push_back(wrapper);
          callbacks2.insert({std::type_index(typeid(EV)), wrapper});
      }

这将尝试添加一个回调，它可以是普通函数指针或std::function。它不适用于 lambda，但会进行参数类型推导。

      template <typename F>
      void addCallback(F cb)
      {
          addCallbackImpl<extract_second_argument_t<F>>(cb);
      };

在两种容器中调用回调。

      void fire (Event& ev)
      {
          std::cout << "callbacks with method 1\n";
          for (auto& cb: callbacks) cb(*this, ev);
  
          std::cout << "callbacks with method 2\n";
          auto range = callbacks2.equal_range(std::type_index(typeid(ev)));
          for (auto& cb = range.first; cb != range.second; ++cb) cb->second(*this, ev);
      }
  };
  

现在是测试驱动程序。

  void cb1 (Widget&, FooEvent&)
  {   
      std::cout << "cb1 called\n";
  }
  
  void cb2 (Widget&, BarEvent&)
  {
      std::cout << "cb2 called\n";
  }
  
  int main()
  {
      Widget w;
  
      w.addCallback(cb1);
      w.addCallback(cb2);
  
      FooEvent foo;
      BarEvent bar;
      w.fire(foo);
      w.fire(bar);
  }

Live demo

更新应该可以从 lambda 中提取参数类型，但我不能保证此方法的可移植性。

为extract_second_argument 添加此专业化：

  template <typename T>
  struct extract_second_argument
  {
      template <typename P, typename A, typename B, typename C, typename ... X>
      static C& extract_second_argument_from_memfun(A (P::* op)(B, C, X...) const);

      template <typename P, typename A, typename B, typename C, typename ... X>
      static C& extract_second_argument_from_memfun(A (P::* op)(B, C, X...));

      using type = std::remove_reference_t
        <decltype(extract_second_argument_from_memfun(&T::operator()))>;
  };

Answer 2

更新示例，每个事件只允许一个回调，无需类型转换或 rtti。

#include <functional>
#include <iostream>
#include <unordered_map>

struct Event
{
};

struct FooEvent : public Event {};
struct BarEvent : public Event {};

class Widget 
{
public:
    // use a function pointer for automatic template deduction
    // todo add specialization for member functions of classes
    template<typename event_t>
    void set_callback(void (*fn)(Widget&, event_t))
    {
        // static asserts tend to give more readable error messages then SFINAE (std::enable_if_t)
        static_assert(std::is_base_of_v<Event, event_t>, "not a valid event type");

        // get the callback map for this for this event type.
        // basically there is one static map for each event_t
        // and event registrations are done based on the widget instance id (m_id)
        auto& callback_map = get_callback_map<event_t>();

        // set the callback for this instance of the widget to the passed function
        callback_map[m_id] = std::function{ fn };
    }

    // select an event firing implementation based on the even type
    template<typename event_t>
    void fire_event(const event_t& ev)
    {
        static_assert(std::is_base_of_v<Event, event_t>, "not a valid event type");

        // again get the callback map
        auto& callback_map = get_callback_map<event_t>();
        auto it = callback_map.find(m_id);
        if (it == callback_map.end()) return;

        auto callback = it->second;
        callback(*this, ev);
    }

private:
    // static function for generating member id's
    static std::size_t get_id()
    {
        static std::size_t id{ 0 };
        return ++id;
    }

    // get the singleton handler map for event_t
    template<typename event_t>
    static auto& get_callback_map()
    {
        static std::unordered_map<std::size_t,std::function<void(Widget&, event_t)>> callback_map;
        return callback_map;
    }

    // the widget's instance id
    std::size_t m_id{ get_id() };
};

//---------------------------------------------------------------------------------------------------------------------

void foo_callback(Widget& widget, FooEvent foo_event)
{
    std::cout << "FooEvent\n";
};

//---------------------------------------------------------------------------------------------------------------------

void bar_callback(Widget& widget, BarEvent bar_event)
{
    std::cout << "BarEvent\n";
};

//---------------------------------------------------------------------------------------------------------------------

int main()
{
    Widget w1;
    Widget w2;
    FooEvent foo_event;
    BarEvent bar_event;

    // register handlers
    w1.set_callback(foo_callback);
    w2.set_callback(bar_callback);

    // show reactions to events
    // w1 will react to foo_event but not to bar_event
    std::cout << "w1 reactions : \n";
    w1.fire_event(foo_event);
    w1.fire_event(bar_event);
    
    std::cout << "w2 reactions : \n";
    w2.fire_event(foo_event);
    w2.fire_event(bar_event);
    

    return 0;
}

Answer 3

不确定我是否理解这个问题。如果是关于获取std::function 的参数之一的类型，您可以使用模板的部分特化。部分特化不适用于函数模板，因此我们需要使用辅助类型：

#include <functional>
#include <iostream>

struct Widget {};
struct Event {
    static void sayHello(){ std::cout << "hello\n";}
};

template <typename F> struct event_from_function;

template <typename EVENT>
struct event_from_function< std::function<void(Widget*,EVENT&)>> {
    using type = EVENT;
};

template <typename F>
void foo(F f) {
    event_from_function<F>::type::sayHello();
}

int main() {
    std::function<void(Widget*,Event&)> f;
    foo(f);    
}

Live Demo.

sayHello 和foo 只是通过从T（即std::function<void(Widget*,Event&>）获取参数类型（Event）来获得一些输出的示例。