将 void* 转换为 std::function<void()>

Question

将不同参数的函数指针存储在一个空指针向量中。

unordered_map<string, vector<void*> > List;

template <typename T>
void Listen(string Name, function<void(T)> Function)
{
    List[Name].push_back(&Function);
}

然后我想给他们打电话，假设T 与Fire 的类型相同，与Listen 使用的类型相同。

template <typename T>
void Fire(string Name, T Data)
{
    auto Functions = List[Name];

    for (auto i = Functions.begin(); i != Functions.end(); ++i)
    {
        (function<void(T)>)i)(Data);
    }
}

但我得到一个编译器错误，显示为error C2064: term does not evaluate to a function taking 1 arguments in file ...\vc\include\xrefwrap 431 1。

我做错了什么？

Answer 1

首先，您在此处获取参数的地址：

List[Name].push_back(&Function);

然后您尝试将迭代器对象转换为 std::function 对象：

(function<void(T)>)i)

你想做的事，可以这样，虽然不好看，委婉地说：

unordered_map<string, vector<void*> > List;

template <typename T>
void Listen(string Name, function<void(T)> &Function)
{
    List[Name].push_back(&Function);
}

template <typename T>
void Fire(string Name, T Data)
{
    auto Functions = List[Name];

    for (auto i = Functions.begin(); i != Functions.end(); ++i)
    {
      function<void(T)> *ptr = *i;

      (*ptr) (Data);
    }
}

它可能会以多种方式中断，例如，您无法控制以 Listen 中的某个名称注册的函数在 Fire 中使用正确的参数调用 - 考虑调用 Listen<int> ("foo", f); 然后执行 @987654328 @

另一种方法 - 只为回调传递闭包：

unordered_map<string, std::vector<function<void()> > > List;

void Listen(string Name, function<void()> Function)
{
    List[Name].push_back(Function);
}

void Fire(string Name)
{
    auto Functions = List[Name];

    for (auto i = Functions.begin(); i != Functions.end(); ++i)
      (*i) ();
}

Answer 2

#include <functional>
#include <unordered_map>
#include <memory>
#include <string>
#include <vector>

template<typename T> struct BlockDeduction{typedef T type;};
struct BaseCallback {
  virtual ~BaseCallback();
  template<typename T>
  void DoCall( typename BlockDeduction<T>::type&& t ) const;
};
template<typename T>
struct Callback: BaseCallback
{
  std::function<void(T)> func;
  Callback( std::function<void(T)> const& f ):func(f) {}
};


template<typename T>
void BaseCallback::DoCall( typename BlockDeduction<T>::type&& t ) const {
  Assert( dynamic_cast<Callback<T>const*>(this) );
  static_cast<Callback<T>const*>(this).func(std::forward(t));
}

typedef std::unique_ptr<BaseCallback> upCallback;
template<typename T>
upCallback make_callback( std::function<void(T)> const& f ) {
  return upCallback( new Callback<T>( f ) );
}


struct Listener {
  std::unordered_map< std::string, std::vector<upCallback>> List;
  template<typename T>
  void Listen( std::string Name, std::function<void(T)> f) {
    List[Name].push_back( make_callback(f) );
  }
  template<typename T>
  void Fire( std::string Name, typename BlockDeduction<T>::type&& t ) {
    auto callbacks = List.find(Name);
    if (callbacks == List.end()) return;
    for(auto it = callbacks->second.begin(); it != callbacks->second.end(); ++it) {
      if (it +1 = callbacks->second.end())
      {
        (**it).DoCall<T>( std::forward(t) );
      } else {
        (**it).DoCall<T>( t );
      }
    }
  }
};

...或类似的东西。

这会将std::function 的副本存储在地图中，通常是包裹起来的。内存通过unique_ptr 处理。我小心地阻止了类型推导，其中类型必须与您安装 Listener 时使用的类型完全相同（此时的自动类型推导相当脆弱）。

在调试中，如果您违反名称类型映射，您将获得断言失败。

需要为 nullary 回调做一些额外的工作。只需编写一个DoCall 将BaseCallback 转换为Callback<void>，将Callback<void> 特化为空值function 包装器，将make_callback 特化为空值function，然后为Listener 编写一个Fire(string) 方法调用裸露的DoCall。

或者创建一个struct Empty 并使用 lambdas 在function<void(Empty)> 中包装空函数，这将涉及的代码略少，但在运行时会更慢。