从专用化访问模板参数

Accessing template arguments from specialization

本文关键字：参数 访问 专用      更新时间：2023-10-16
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<int, char[I]>内部访问类型 T (= int (，而无需显式编写专用化中的类型？

像这样：

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中提取参数。

此版本可以通过如下接口使通用版本：

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进行第一次传递;使用元组的缺点是它们是重类型，而重类型的元编程会降低性能，有时会导致其他问题。

简单地说，

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

你可以试试这个：

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