Function 使用成员函数作为模板参数来创建静态包装

我正试图围绕c API编写一个c++11包装器，基本上有一种用静态函数指针注册通知的方法，它也会将一个“不透明”指针传回给我，这是稍后提供的，基本上是指向我创建的类的指针，在本例中是

类foo

。基本上，我试图创建一个静态函数：助手：：调用具有API的签名，但是生成代码来调用C++包装器创建的实例上的成员函数，并通过一个“不透明”指针传递给它。然后，当最终调用成员函数时，该静态函数也会转换参数

我似乎已经基本实现了，但在本例中，我很难创建一个“更好”的公共函数

register\u handler

，它隐藏了“更丑陋”的内部结构。这就是我得到的错误：

test.cpp:154:37: error: no matching function for call to ‘register_handler<&foo::bar>(const char [6])’
  154 |  register_handler<&foo::bar>("test2"); // <-- trying to wrap it into a function so I can use only one template argument
      |                                     ^
test.cpp:137:6: note: candidate: ‘template<class T, class R, class ... Args, R (T::* Func)(Args ...)> void register_handler(const char*)’
  137 | void register_handler(const char* name)
      |      ^~~~~~~~~~~~~~~~

test.cpp:154:37:错误：调用“register\u handler（const char[6]）没有匹配的函数
154 |寄存器处理程序（“test2”）；//
结构索引{
typedef索引next；
};
模板
结构生成索引{
typedef typename生成索引：：type:：next type；
};
模板
结构生成索引<0>{
类型定义索引类型；
};
结构值
{
std:：string str；
模板
值（T val）：
str_（std:：to_string（val））
{
}
值（常量字符*str）：
str_（str）
{
}
值（常量std:：string和str）：
str_（str）
{
}
运算符int（）常量
{
返回std：：stoi（str_u2;）；
}
运算符double（）常量
{
返回std：：stof（str_）；
}
运算符std:：string（）常量
{
返回str；
}
};
映射g_处理器；
模板
结构助手；
模板
结构辅助程序
{
模板
静态无效扩展（T*obj，常量std:：向量和参数，索引）
{
assert（sizeof…（Is）*Func）（（args[Is]）…）；
}
静态void调用（void*p，const std:：vector和args）
{
T*obj=重新解释铸件（p）；
展开（obj，args，typename make_index:：type（））；
}
静态void reg_处理程序（常量字符*名称）
{
insert（std:：make_pair（name，call））；
};
};
模板
void call_handler（Obj&Obj，const char*name，const std:：vector&args）
{
auto it=g_handlers.find（name）；
if（it！=g_handlers.end（））
it->second（重新解释投射（&obj），args）；
其他的
对于C++11，简单的答案是：你不能

在C++17中，您还可以对非类型模板参数使用
auto
，因为函数指针或成员函数指针不是这里的类型，并且您没有描述函数指针类型的语法

在C++17中，您可以这样使用它：

struct foo 
{   
    void bar(){}
};  

template <typename T, T>
struct helper;

template <typename T, typename R, typename... Args, R(T::*Func)(Args...)>
struct helper<R(T::*)(Args...), Func>
{   
    static void reg_handler(const char* name)
    {
        // ...  here your code continues
    }   
};

template < auto T > 
struct X
{   
};  

template <typename T, typename R, typename... Args, R(T::*Func)(Args...)>
struct X<Func>
{   
    static void register_handler( const char* name )
    {   
        helper<R(T::*)(Args...), Func>::reg_handler(name);
    }   
};  

int main()
{
    X<&foo::bar>::register_handler("check");
}

structfoo
{   
无效条（）{}
};  
模板
结构助手；
模板
结构辅助程序
{   
静态void reg_处理程序（常量字符*名称）
{
//…这里继续您的代码
}   
};
模板
结构X
{   
};  
模板
结构X
{   
静态无效寄存器\u处理程序（常量字符*名称）
{   
助手：：reg_处理程序（名称）；
}   
};  
int main（）
{
X：：寄存器处理程序（“检查”）；
}