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

有没有办法从类模板特化T中访问类型int（= A<int, char[I]>），而没有明确写出特化中的类型？

Answer 1

这样的事情：

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

的工作原理。如果有人实际传递了第二个T和U问题的类型，那么......

另一种方法是：

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

我们有一个using别名，用于从我们在专业化中使用的通用A中提取args。

此版本可以通过以下界面制作通用：

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;

注意它只适用于只接受类型参数的模板。（实现留作练习。我可能会使用tuple_element作为第一遍;使用元组有缺点，它们是重型，而重型的元编程会吮吸性能，有时会导致其他问题。）< / p>

Answer 2

简单地说，

#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, "");
}

Answer 3

你可以试试这个：

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

从专业化访问模板参数

3 个答案: