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

Question

存储函数指针在void指针向量中具有不同参数。

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

然后你要一个iterator对象转换为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);，然后做Fire<double> ("foo", 3.14);

另一种方法 - 只是通过回调封：

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时使用的点类型（当时的自动类型演绎相当脆弱）的类型演绎。

在调试中，如果违反名称< - >类型映射，则会出现断言失败。

一些额外的工作需要完成无限的回调。只要写一个DoCall是蒙上BaseCallback到Callback<void>，专门Callback<void>是一个无参function包装上无参function专门make_callback，谱写Fire(string)方法Listener调用裸DoCall。

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