作为模板参数和签名的函数指针

Question

我可以将“通用”函数指针作为模板参数传递给它的签名吗？我知道我可以函数签名传递给一个模板：

template<typename signature> 
struct wrapper; 

template<typename RT, typename... ATs> 
struct wrapper<RT (ATs...)> {}; 

int f(int, double) 

wrapper<decltype(f)> w; 

我也可以传递一个函数指针作为非类型模板参数：

template<int (*pF)(int, double)> myTemp() { 
     pf(1, 1.0); 
    } 

    myTemp<f>(); 

我想什么做的是什么像这样

template<typename RT (*pF)(typename ATs...)> 

这可能吗？函数指针必须作为模板参数传递，并且不能作为函数参数传递。

---

我想使用模板来包装c函数，并使它们可以从lua调用。以下代码有效（C++ 14，gcc，lua-5.3），但可以改进。

#include <iostream> 
#include <type_traits> 

extern "C" { 
#include <lua.h> 
#include <lualib.h> 
#include <lauxlib.h> 
} 

using namespace std; 

int add(int i, int j) { 
    cout << "adding " << i << " to " << j << "." << endl; 
    return i + j; 
} 

int sub(int i, int j) { 
    cout << "subtracting " << j << " from " << i << "." << endl; 
    return i - j; 
} 

// **************************** 

template<typename signature> 
struct wrapper; 

template<typename RT, typename... ATs> 
struct wrapper<RT (ATs...)> { 

    template<RT (*pF)(ATs...)> 
    void reg(lua_State *L, const char*n) { 
     auto lw = [](lua_State *L) -> RT { 
      lua_pushnumber(L, call<0>(pF, L)); 
      return 1; 
     }; 
     lua_pushcfunction(L, lw); 
     lua_setglobal(L, n); 
    } 

    template<int i, typename... ETs> 
    static 
    typename std::enable_if<i != sizeof...(ATs), RT>::type 
    call(RT (*f)(ATs...), lua_State *L, ETs... Es) { 
     auto arg = lua_tonumber(L, i+1); 
     return call<i+1>(f, L, Es..., arg); 
    } 

    template<int i, typename... ETs> 
    static 
    typename std::enable_if<i == sizeof...(ATs), RT>::type 
    call(RT (*f)(ATs...), lua_State *L, ETs... Es) { 
     return f(Es...); 
    } 

}; 

#define regLua(L, fct, str) wrapper<decltype(fct)>().reg<fct>(L, str) 

int main() { 
    lua_State *L = luaL_newstate(); 
    luaL_openlibs(L); 

    luaL_dostring(L, "print(\"Hello World!\")"); 

    // Ugly: add must be passed two times! Not a very userfriendly syntax. 
    wrapper<decltype(add)>().reg<add>(L, "add"); 
    // Looks better, but uses a macro... 
    regLua(L, sub, "sub"); 
    // optimal (but possible??): 
    // wrap<sub>(L, "sub"); 

    luaL_dostring(L, "print(\"add:\", add(3, 5))"); 
    luaL_dostring(L, "print(\"sub:\", sub(3, 5))"); 

    lua_close(L); 

    return 0; 
} 

Answer 1

C++ 17将允许

template <auto value> struct wrapper; 

，然后你的专业化

template<typename RT, typename... ATs, RT (*pF)(ATs...)> 
struct wrapper<pF> { 
    static void reg(lua_State *L, const char* n) { 
     auto lw = [](lua_State *L) { 
      lua_pushnumber(L, call(L, std::index_sequence_for<ATS...>())); 
      return 1; 
     }; 
     lua_pushcfunction(L, lw); 
     lua_setglobal(L, n); 
    } 

    template<std::size_t ... Is> 
    static 
    RT call(lua_State *L, std::index_sequence<Is...>) { 
     return pF(lua_tonumber(L, 1 + Is)...); 
    } 
}; 

与用法：

wrapper<&add>::reg(L, "add"); 

之前C++ 1Z，你wrapper有

template <typename Sig, sig Pf> struct wrapper; 

template<typename RT, typename... ATs, RT (*pF)(ATs...)> 
struct wrapper<Rt (*)(ATS...), pF> { 
    // Code 
}; 

这迫使你重复的函数名（如果您没有手动键入其签名）

wrapper<decltype(&add), &add>::reg(L, "add");