전문 기능

Question

으로 기능 유형을 제외하고 당겨 분리 this question 추천 클래스 템플릿을 사용하여 기능 유형에 대한 대답은 : 여기 수행되고 있었는지 연구로

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

내 희망은 대신 decltypeargs<decltype(foo)>를 호출해야하는 tuple 유형을 얻을 수 decltype(myTry<decltype(foo)>())를 호출 할 수 있었다. 함수 선언으로이를 수행 할 수있는 방법이 있습니까?

Answer 1

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

Answer 2

함수는 이와 같이 특수화 될 수는 없지만이를 위해 함수를 특수화 할 필요는 없습니다. 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; 
} 

Answer 3

, 당신은 어느 직전에서 동일한 유형의 특성을 다시 사용할 수 있습니다 :

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