C++：如何通过函数指针，保存在一个局部变量，作为模板参数

Question

using namespace std; 

float test1(float i){ 
    return i * i; 
} 

int test2(int i){ 
    return i+9; 
} 

struct Wrapper{ 

    typedef void (*wrapper_type)(int); 

    template<class R, class A> 
    void wrap(string name,R (*fn) (A)){ 
     wrapper_type f_ = &Wrapper::wrapper1<R,A,fn>; 
     // in the real program, f_ would be passed in an array to some c library 
     wrappers[name] = f_; 
    } 

    void run(int i){ 
     map<string,wrapper_type>::iterator it, end = wrappers.end(); 
     for(it=wrappers.begin();it!=end;it++){ 
      wrapper_type wt = (*it).second; 
      (*wt)(i); 
     } 
    } 

    template<class R, class A, R (*fn) (A)> 
    static void wrapper1(int mul){ 
     //do something 
     A arg = mul; 
     R result = (*fn)(arg); 
     cout << "Result: " << result << endl; 
    } 

    map<string,wrapper_type> wrappers; 

}; 

int main(int argc, char** argv) { 
    Wrapper w; 
    w.wrap("test1",&test1); 
    w.wrap("test2",&test2); 
    w.run(89); 
    return 0; 
} 

这里的G ++错误：

main.cpp:31: error: ‘fn’ is not a valid template argument for type ‘float (*)(float)’ because function ‘fn’ has not external linkage 

从我个人理解，这个问题是一个局部变量无连锁;因此它不能用作模板参数。

所以，我想知道是否有办法解决这个问题或其他技术来完成相同的？

谢谢。

编辑1：

我完全理解，我无法通过不能在编译时作为模板放慢参数来确定的值。我问的是 - 有没有更好的方法来做到这一点？现在，对我的作品的解决办法是：

template<class R, class A,R (*fn) (A)> 
void wrap(string name){ 
    wrapper_type f_ = &Wrapper::wrapper1<R,A,fn>; 
    // in the real program, f_ would be passed in an array to sm c library 
    wrappers[name] = f_; 
} 

，并呼吁为：

w.wrap<float, float, &test1>("test1"); 
w.wrap<int, int, &test2>("test2"); 

但在这里，我包裹中传递的参数类型。有没有办法避免这种情况？

编辑2：

只是为了澄清或添加更多的信息：我想呈现给用户的界面具有类似于LuaBind或Boost.Python的即Wrapper.wrap（“测试1”，&测试1） ;应该足够了。

Answer 1

在编译时必须知道模板参数，因此您必须重新设计代码并将其考虑在内。

编辑：为您更新的问题使用Boost function_traits。

template<R (*fn) (A)> 
void wrap(string name){ 
    wrapper_type f_ = &Wrapper::wrapper1<function_traits<A>::result_type, function_traits<A>::arg1_type,fn>; 
    // in the real program, f_ would be passed in an array to sm c library 
    wrappers[name] = f_; 
} 

Answer 2

无法将存储在变量中的函数指针作为模板参数传递。即使变量在编译时是恒定的并且已知的。但它有可能通过一个函数指针字面：

void foo() { 
} 

typedef void (FunctionPtr*)(); 

template<FunctionPtr F> 
void wrap() { 
    F(); 
} 

，然后调用：

wrap<&foo>(); 

我已经解决了类似的问题here。

Answer 3

如何在共享一个通用接口的类中封装“test *”函数然后将这些类传递给模板？

Answer 4

函数的地址在编译期间（仅在链接时稍后）是未知的，在编译时必须知道模板参数。

解决这个问题的方法正是您在第一个换行函数中所做的：将其作为函数参数。

Answer 5

如何使用一组类有同名静态成员函数

struct FirstAlternative { 
    static void DoStuff(); 
}; 

struct SecondAlternative { 
    static void DoStuff(); 
}; 

template<class R, class A, class Alternative> 
void wrap(string name) (A)){ 
    wrapper_type f_ = &Wrapper::wrapper1<R,A,&Alternative::DoStuff>; 
    wrappers[name] = f_; 
} 

，然后通过class Alternative作为参数传入从调用站点模板？