C++ 11索引模板参数包在运行时以访问第N类型

Question

从这个SO主题(和这篇博文),我知道如何在模板参数包中访问第N类型.例如,上述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...>;

会导致编译错误:

错误:非类型模板参数不是常量表达式

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

---

这是我的用例:

我的程序读取一个文本文件,它基本上是一个数字数组.每个数字i指的是我的类基于模板化的模板参数包的第i种类型.基于该类型,我想声明该类型的变量并对其执行不同的操作.例如,如果它是一个字符串,我想声明一个字符串并进行字符串匹配,如果它是一个整数,我想计算一个数字的平方根.

Answer 1

C++ 是静态的吗？打字语言。因此，在编译时需要知道所有变量的类型（并且不能改变）。您需要依赖于运行时值的类型。幸运的是，C++ 还具有对象的动态类型。

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

要使用此功能，您需要所谓的多态基类：一个具有（至少）一个virtual成员函数的类，您可以从中派生出更多的类。

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

然后，您可以拥有一个静态类型的指针或对该基类的引用的变量，它可以指向/引用来自基类和任何派生类的对象。如果您有明确定义的接口，则将其编码为虚拟成员函数（想想Shapeand area ()、name ()、... 函数）并通过该基类指针/引用进行调用（如另一个答案所示）。否则，使用（隐藏的）动态转换来获取具有动态类型的静态类型的指针/引用：

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

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

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

因此，如果您在编译时知道必须能够存储的类型集，那么您可以（在编译时）计算所需的最大大小，使用该大小的静态数组并在该数组中构造您的对象（因为C++11 你也可以用 (recursive template) 实现同样的效果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)...);
  }
};