传递的boost ::任何以提振结果::绑定

Question

我试图找出如何写这个函数：

template <typename Bound> 
Bound::result_type callFromAnyList(Bound b, list<any> p) 
{ 
} 

然后，如果我有一些功能：

double myFunc(string s, int i) 
{ 
    return -3.0; 
} 

list<any> p; 
p.push_back((string)"Hello"); 
p.push_back(7); 
double result = callFromAnyList(bind(myFunc, _1, _2), p); 

是否有可能写出像我callFromAnyList功能：我可以做这样的称呼呢？您可以检查从bind返回的类型的结果类型和参数类型吗？然后致电any_cast<P1>(*p.begin())等？我试图理解绑定代码，但是它有点难以遵循，并且看起来并不像他们在考虑时所写的那样。

Answer 1

正如你在评论部分更新了你的担忧，这里的答案。刚开函数的返回类型是可能的：

template<typename> 
struct return_of; 

template<typename R> 
struct return_of<R(*)()> { 
    typedef R type; 
}; 

template<typename R, typename P1> 
struct return_of<R(*)(P1)> { 
    typedef R type; 
    typedef P1 parameter_1; 
}; 

void foo(int); 

template<typename Func> 
typename return_of<Func>::parameter_1 bar(Func f) { 
    return 42; 
} 

// call: bar(foo); 

我猜你看看这是什么归结为:)你可以使用已解决了这个问题升压功能类型：http://www.boost.org/doc/libs/1_37_0/libs/function_types/doc/html/index.html

Answer 2

我落得这样做这对于现在 -

void invoke(void (f)(), list<any>& params) 
{ 
    f(); 
} 

template <typename R> 
void invoke(R (f)(), list<any>& params) 
{ 
    params.push_front(f()); 
} 

template <typename T0> 
void invoke(void (f)(T0), list<any>& params) 
{ 
    T0 t0 = any_cast<T0>(*params.begin()); params.pop_front(); 
    f(t0); 
} 

template <typename R, typename T0> 
void invoke(R (f)(T0), list<any>& params) 
{ 
    T0 t0 = any_cast<T0>(*params.begin()); params.pop_front(); 
    params.push_front(f(t0)); 
} 

template <typename T0, typename T1> 
void invoke(void (f)(T0, T1), list<any>& params) 
{ 
    T0 t0 = any_cast<T0>(*params.begin()); params.pop_front(); 
    T1 t1 = any_cast<T1>(*params.begin()); params.pop_front(); 
    f(t0, t1); 
} 

template <typename R, typename T0, typename T1> 
void invoke(R (f)(T0, T1), list<any>& params) 
{ 
    T0 t0 = any_cast<T0>(*params.begin()); params.pop_front(); 
    T1 t1 = any_cast<T1>(*params.begin()); params.pop_front(); 
    params.push_front(f(t0, t1)); 
} 

template <typename T0, typename T1, typename T2> 
void invoke(void (f)(T0, T1, T2), list<any>& params) 
{ 
    T0 t0 = any_cast<T0>(*params.begin()); params.pop_front(); 
    T1 t1 = any_cast<T1>(*params.begin()); params.pop_front(); 
    T2 t2 = any_cast<T2>(*params.begin()); params.pop_front(); 
    f(t0, t1, t2); 
} 

template <typename R, typename T0, typename T1, typename T2> 
void invoke(R (f)(T0, T1, T2), list<any>& params) 
{ 
    T0 t0 = any_cast<T0>(*params.begin()); params.pop_front(); 
    T1 t1 = any_cast<T1>(*params.begin()); params.pop_front(); 
    T2 t2 = any_cast<T2>(*params.begin()); params.pop_front(); 
    params.push_front(f(t0, t1, t2)); 
} 

我缺乏提升的全功率::绑定 - 样，我无法处理方法指针 - 但我也意识到，这样做，我有一个堆栈处理器。我可以继续调用堆栈上参数的运算符方法。