从这里SO topic (和这个 blog post )，我知道如何访问模板参数包中的第 N 类型。例如，one of the answers对于上述 SO 问题表明:

template<int N, typename... Ts> using NthTypeOf = typename std::tuple_element<N, std::tuple<Ts...>>::type;

using ThirdType = NthTypeOf<2, Ts...>;

但是，这些方法仅在编译时有效。尝试做一些事情，例如:

int argumentNumber = 2;
using ItsType = NthTypeOf<argumentNumber, Arguments...>;

会导致编译错误:

Error : non-type template argument is not a constant expression

有没有办法在运行时访问第 N 类型？

这是我的用例:

我的程序读取一个文本文件，它基本上是一个数字数组。每个数字 i 指的是第 i 类型的模板参数包，我的类基于该模板参数包。基于该类型，我想声明一个该类型的变量并用它做一些不同的事情。例如，如果是一个字符串，我想声明一个字符串并进行字符串匹配，如果是一个整数，我想计算一个数字的平方根。

最佳答案

C++ 是一种静态 类型语言。因此，所有变量的类型都需要在编译时知道(并且不能变化)。您需要一个依赖于运行时值的类型。幸运的是，C++ 还具有 动态 对象 类型的功能。

警告:此答案中的所有代码仅用于演示基本概念/想法。它缺少任何类型的错误处理、健全的接口(interface)(构造函数……)、异常安全……。所以不要用于生产，考虑使用 boost 提供的实现。

要使用此功能，您需要所谓的多态基类:一个具有(至少)一个虚拟成员函数的类，您可以从中派生出更多的类。 p>

struct value_base {
  // you want to be able to make copies
  virtual std::unique_ptr<value_base> copy_me() const = 0;
  virtual ~value_base () {}
};

template<typename Value_Type>
struct value_of : value_base {
  Value_Type value;

  std::unique_ptr<value_base> copy_me() const {
    return new value_of {value};
  }
};

然后您可以拥有一个具有静态指针类型的变量或指向该基类的引用，它可以指向/引用来自基类和任何派生类的对象。如果您有一个明确定义的接口(interface)，那么将其编码为虚拟成员函数(想想Shape 和area ()，name ( ), ... 函数) 并通过该基类指针/引用 ( as shown in the other answer ) 进行调用。否则使用(隐藏的)动态转换来获取具有动态类型的静态类型的指针/引用:

struct any {
  std:: unique_ptr<value_base> value_container;

  // Add constructor

  any(any const & a)
    : value_container (a.value_container->copy_me ())
  {}
  // Move constructor

  template<typename T>
  T & get() {
    value_of<T> * typed_container
        = dynamic_cast<value_of<T> *>(value_container.get();)
    if (typed_container == nullptr) {
      // Stores another type, handle failure
    }
    return typed_container->value;
  }

  // T const & get() const;
  // with same content as above
};

template<typename T, typename... Args>
any make_any (Args... && args) {
  // Raw new, not good, add proper exception handling like make_unique (C++14?)
  return {new T(std:: forward<Args>(args)...)};
}

由于对象构造是在运行时完成的，因此指向/引用对象的实际类型可能取决于运行时值:

template<typename T>
any read_and_construct (std:: istream & in) {
  T value;
  // Add error handling please
  in >> value;
  return make_any<T>(std:: move (value));
}

// ...

// missing: way of error handling
std::map<int, std:: function<any(std:: istream &)>> construction_map;
construction_map.insert(std::make_pair(1, read_and_construct<double>));
// and more
int integer_encoded_type;
// error handling please
cin >> integer_encoded_type;
// error handling please
any value = construction_map [integer_encoded_type] (cin);

您可能已经注意到，上面的代码还使用了明确定义的构造接口(interface)。 如果您不打算对返回的 any 对象做很多不同的事情，可能会在程序运行的大部分时间内将它们存储在各种数据结构中， then 使用 any 类型很可能是矫枉过正，您也应该将依赖于类型的代码也放入那些构造函数中。

这种 any 类的一个严重缺点是它的通用性:它可以在其中存储几乎任何类型。这意味着(实际)存储对象的(最大)大小在编译期间是未知的，因此不可能使用具有自动持续时间的存储(“堆栈”)(在标准 C++ 中)。这可能会导致动态内存(“堆”)的昂贵使用，这比自动内存慢相当。每当必须制作 any 对象的许多拷贝时，这个问题就会浮出水面，但如果您只是保留它们的集合，则可能无关紧要(缓存位置除外)。

因此，如果您在编译时知道必须能够存储的类型集，那么您可以(在编译时)计算所需的最大大小，使用该类型的静态数组调整大小并在该数组中构建对象(自 C++11 起，您也可以使用(递归模板)union 实现相同的目的):

constexpr size_t max_two (size_t a, size_t b) {
  return (a > b) ? a : b;
}

template<size_t size, size_t... sizes>
constexpr size_t max_of() {
  return max_two (size, max_of<sizes>());
}

template<typename... Types>
struct variant {
  alignas(value_of<Types>...) char buffer[max_of<sizeof (value_of<Types>)...>()];
  value_base * active;

  // Construct an empty variant
  variant () : active (nullptr)
  {}

  // Copy and move constructor still missing!

  ~variant() {
    if (active) {
      active->~value_base ();
    }
  }

  template<typename T, typename... Args>
  void emplace (Args... && args) {
    if (active) {
      active->~value_base ();
    }
    active = new (buffer) T(std:: forward<Args>(args)...);
  }
};

关于C++11 在运行时索引模板参数包以访问第 N 类型，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44551908/