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

Question

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

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 function中的模板arguments，使用方法如下：

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;
}

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

如果可能的话，function 应该是这样的：

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

不确定我是否理解这个问题。 如果要获取std::function的 arguments 之一的类型，则可以使用部分专业化。 部分特化不适用于 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);    
}

现场演示。

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

Answer 2

这是一些不使用reinterpret_cast并自动进行演绎的代码（在许多但不是所有情况下）。 代码完整且可运行，但被纯文本中断（比等宽注释更易读）。

  #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 和其他 function 对象或指向成员的指针。

  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;

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

  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;

这添加了任何性质的回调（普通 function、 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});
      }

这将尝试添加一个简单的 function 指针或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);
  }

现场演示

Answer 3

也许 lambda 函数在这里可以提供帮助（让他们做所有的模板魔法）。 https://en.cppreference.com/w/cpp/language/lambda

例子：

#include <functional>
#include <iostream>

struct FooEvent {};
struct BarEvent {};

class Widget 
{
public:
    void set_callback(std::function<void()> callback) 
    {
        m_callback = callback;
    }

    void fire_event()
    {
        m_callback();
    }

    std::function<void()> m_callback{ [] {} }; // standard lambda callback that does nothing (null strategy pattern , avoids if/then constructs
};

// Reference instead of pointer, widget must be a valid object 
// avoids if nullptr checks.
void callback(Widget& widget, BarEvent bar_event)
{
    std::cout << "BarEvent\n";
};

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


int main()
{
    Widget w1;
    Widget w2;
    FooEvent ev1;
    BarEvent ev2;
    
    // [&w1,ev1]{...} <== this is a lambda function
    // capture w1 by reference so it is not copied 
    // capture event ev1 by value, copy it it could be a local object
    // how you capture in your code is dependent on the lifetime of widgets and events. this is an example only
    
    w1.set_callback([&w1, ev1] { callback(w1, ev1); });
    w2.set_callback([&w2, ev2] { callback(w2, ev2); });

    w1.fire_event();
    w2.fire_event();

    return 0;
}