C++ 使用decltype with宏显式实例化类成员函数

我正在尝试扩展用于模板成员函数，但我没有运气。目前试图使这项工作看起来像：

// header
struct my_class
{
    template <typename T>
    some_type my_func(T val);
};

//source
template <typename T> 
some_type my_class::my_func(T val)
{
    ....
}

// attempt a
template decltype(my_class::my_func<int>) my_class::my_func<int>; 

// attempt b
template std::remove_pointer<decltype(&my_class::my_func<int>)>::type my_class::my_func<int>;

//头
构造my_类
{
模板
某些类型的my_func（T val）；
};
//来源
模板
某些类型my_类：：my_func（T val）
{
....
}
//尝试
模板decltype（my_class:：my_func）my_class:：my_func；
//尝试b
模板std:：remove_pointer:：type my_class:：my_func；

这可能吗？如果是这样的话，我有什么想法可以使这项工作

编辑：

因此，这似乎需要一些编译器更新，仅在clang或GCC6.1+中可用。@yakk提供的以下代码适用于const方法：

template <class T>                                                                                                                                                                
struct pointer_to_member_function{};                                                                                                                                                                                

template <typename pmf_t> 
using pointer_to_member_signature
    = typename pointer_to_member_function<pmf_t>::signature;

template <class ret_t, class class_t, class...args>                                                                                                                               
struct pointer_to_member_function<ret_t(class_t::*)(args...) const>                                                                                                               
{                                                                                                                                                                                 
     using signature = ret_t(args...) const;  
};

模板
指向成员函数{}的结构指针{u；
模板
使用指向成员签名的指针
=指向成员函数的typename指针：：签名；
模板
指向成员函数的结构指针
{                                                                                                                                                                                 
使用签名=返回（参数…）常量；
};

但是，以下修改不会在所有常量中编译：

template <class function_t, class class_t>                                                                                                                               
struct pointer_to_member_function<function_t class_t::*>                                                                                                               
{                                     
   using signature = function_t;                                                                                                                                             
};            

模板
指向成员函数的结构指针
{                                     
使用签名=函数\u t；
};            

我不知道这是否符合标准，但它的工作原理是：

template<class Pmf>
struct pmf_sig{};
template<class Pmf>
using pmf_sig_t=typename pmf_sig<Pmf>::type;
template<class R, class T, class...Args>
struct pmf_sig<R(T::*)(Args...)>{
  using type=R(Args...);
};

用途：

template<> pmf_sig_t<decltype(&my_class::my_func<int>)> my_class::my_func<int>;

模板pmf_sig_t my_class:：my_func；

或：

模板pmf_sig_t my_class:：my_func；

其思想是，

my_class:：

在某种意义上不是签名的一部分

---

.

这适用于非常量成员函数，但当常量符合条件时，它会崩溃。我在康斯特专业方面一点运气都没有。想法？这似乎只适用于clang和gcc 6.1+？对于较小的gcc版本，这里缺少什么语言要求？见@mgoldman。我意识到这种技术的变化是有效的（在不同的环境下），所以我建议在这里尝试；我不知道标准中这种技术的基础。

template<> pmf_sig_t<decltype(&my_class::my_func<int>)> my_class::my_func<int>;

template pmf_sig_t<decltype(&my_class::my_func<int>)> my_class::my_func<int>;