Erişme şablon argümanları

Question

template<typename T, typename U> 
struct A; 

template<std::size_t I> 
struct A<int, char[I]> { 
    using pointer = T*; // does not compile 
}; 

int main() { 
    A<int, char[3]> a;  
} 

açıkça uzmanlıkta sahiptir türü yazmadan, sınıf şablonu uzmanlık A<int, char[I]> içinden türünü T (= int) erişmek için herhangi bir yolu var mı?

Answer 1

şey:

template<class T, class U, class=T, class=U> 
struct A; 

template<std::size_t I, class T, class U> 
struct A<int, char[I], T, U> { 
    using pointer = T*; 
}; 

eser. Birisi aslında ...

geliştirmek ikinci T ve U sorunları için bir tür geçer, ama varsa başka bir yaklaşım geçerli:

template<class T, class U> 
struct A; 

// get args from an instance! 
template<class A> 
struct A_Args; 
template<class T_, class U_> 
struct A_Args<A<T_,U_>> { 
    using T = T_; using U = U_; 
}; 
template<class A> 
using A_T = typename A_Args<A>::T; 
template<class A> 
using A_U = typename A_Args<A>::U; 

// reflect on our troubles: 
template<std::size_t I> 
struct A<int, char[I]> { 
    using pointer = A_T<A>*; 
}; 

biz kullandığımız bir jenerik A gelen args ayıklar bir using takma adına sahip yerlerde uzmanlık içinde. sadece tek tip bağımsız değişkenler alan şablonlar ile çalışacak not ile

template<std::size_t I, class Instance> 
struct nth_template_arg; 
template<std::size_t I, class Instance> 
using nth_template_arg_t=typename nth_template_arg<I, Instance>::type; 

:

Bu sürüm

gibi bir arayüz ile jenerik yapılabilir. (Uygulama bir egzersiz olarak bırakılmıştır Muhtemelen ilk geçiş için tuple_element kullanmayı tercih ediyorum;. Dizilerini kullanarak ağır türleridir dezavantajı var, ve ağır türleri ile metaprogramming diğer sorunlara performansı berbat ve bazen neden olur.)

Answer 2

Bu deneyebilirsiniz: Böyle

template<typename T, typename U, std::size_t I> 
struct A{ 
    using pointer = T*; 
}; 

Answer 3

Basitçe,

#include <type_traits> 

template<class T, class U> 
struct foo; 

template<class T, std::size_t Index> 
struct foo<T, char[Index]> 
{ 
    using type = T; 
}; 

int 
main() 
{ 
    static_assert(std::is_same<foo<int, char[3]>::type, int>::value, ""); 
}