具有专用函数的Pull-Apart函数类型

Pull Apart Function Type With Specialized Function

本文关键字：函数 Pull-Apart 类型 专用      更新时间：2023-10-16

这个问题的答案使用类模板来挑选一种函数类型：

template <typename T>
struct function_args {};
template <typename R, typename... Args>
struct function_args<R(Args...)> {
    using type = tuple<Args...>;
};
template <typename T>
using decltypeargs = typename function_args<T>::type;

当我研究这里正在做的事情时，我试图重写function_args。我尝试使用一个函数来完成此操作，以消除对decltypeargs模板的需要。但我发现自己陷入了不恰当的语法：

template <typename T>
tuple<> myTry();
template <typename Ret, typename... Args>
tuple<Args...> myTry<Ret(Args...)>();

我的希望是调用decltype(myTry<decltype(foo)>())来获得tuple类型，而不是必须调用decltypeargs<decltype(foo)>。有没有一种方法可以通过函数声明来实现这一点？

使用一个函数，您可以重用以前的相同类型特征：

template <typename T>
function_args<T> myTry();

或者，您可以用函数重新实现相同的功能。你不能部分专门化函数模板，但你可以重载：

namespace detail {
    template <class T> struct tag { };
    template <class R, class... Args>
    tag<std::tuple<R, Args...>> myTry(tag<R(Args...)> );
    template <class R, class C, class... Args>
    tag<std::tuple<R, Args...>> myTry(tag<R(C::*)(Args...)> );        
    // etc.
}
template <typename T>
auto myTry() { return detail::myTry(detail::tag<T>{}); }

//------------------------ Machinery:
#include <tuple>
template< class Ret, class... Args >
std::tuple<Args...> m( Ret(Args...) );
//------------------------- Example:
#include <iostream>
#include <typeinfo>
void foo( double );
using namespace std;
auto main()
    -> int
{
    using Args_tuple = decltype( m( foo ) );
    cout << typeid( Args_tuple ).name() << endl;
}

函数不能像那样专门化，但不需要为此专门化函数。用gcc 6.1.1:测试

#include <iostream>
#include <tuple>
template <typename T> struct my_try;
template <typename Ret, typename... Args>
struct my_try<Ret(Args...)> {
    std::tuple<Args...> operator()();
};
template<typename T>
auto MyTry()
{
    return my_try<T>()();
}

void foo(int, char);
int main()
{
    decltype(MyTry<decltype(foo)>()) t;
    int *a= &std::get<0>(t);
    char *b= &std::get<1>(t);
    return 0;
}
相关文章：