使用宏观使用宏来明确实例化类成员函数

Using decltype with macro for explicit instantiation of class member functions

本文关键字:函数 实例化 成员 宏观      更新时间:2023-10-16

我正在尝试扩展我可以使用dectType(或类似的内容)进行显式模板实例化而无需签名重复吗?用于模板成员功能,但我没有运气。当前的尝试使这项工作看起来像:

// 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>;

这可能吗?如果是这样,我对如何完成这项工作有任何想法吗?

编辑:

因此,似乎仅在Clang或GCC 6.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;  
};

但是,以下修改确实在所有constness上进行了编译:

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

我不知道这是否是标准的,但它在clang中起作用:

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...);
};

然后constconst&&&支持:

template<class R, class T, class...Args>
struct pmf_sig<R(T::*)(Args...) const>{
  using type=R(Args...) const;
};
template<class R, class T, class...Args>
struct pmf_sig<R(T::*)(Args...) const&>{
  using type=R(Args...) const&;
};
template<class R, class T, class...Args>
struct pmf_sig<R(T::*)(Args...) const&&>{
  using type=R(Args...) const&&;
};
template<class R, class T, class...Args>
struct pmf_sig<R(T::*)(Args...) &&>{
  using type=R(Args...) &&;
};
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>;

或:

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

想法是my_class::在某种意义上不是签名的一部分。

实时示例。