c++11 可变参数编程，如何定义 vector 塔

Question

如何(如果可能)使用 c++11 可变参数编程来定义一系列 vector 's 在函数体中，(或者换句话说，N 维数组的序列，N 's 递减直到 0)，就像下面的变量？

vector<vector<vector<int>>> v<3>;
vector<vector<int>> v<2>;
vector<int> v<1>;
int v<0>;

我的想象是这样的:

#include <iostream>
#include <vector>
using namespace std;

template<int ...> struct seq {};
template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};
template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };

template<int ...S>
void f(seq<S...>) {
  //how do I write definitions of v<N> here?
  vector<vector<...(N layers)<vector<int> ...> v<N>;     //??how-to, not valid c++
  vector<vector<...(N -1 layers)<vector<int> ...> v<N-1>;//??how-to, not valid c++
  //...
  vector<int> v<1>;  //??how-to, not valid c++
  int v<0>;          //??how-to, not valid c++

  //...
}

int main() {
  f(typename gens<3>);
  return 0;
}

另外，这在 c++14 中会更容易吗？

谢谢，

--编辑--

澄清一下，我所说的“vector 塔”最好用 N 元组 (v_1, v_2, ..., v_N) 来描述，其中 N 是一个积分模板参数。 v_1 属于 vector ，v_2 属于 vector >，以此类推。

--EDIT2--

到目前为止，quantdev 和 R 的答案已经成功解决了为任何固定的 N 定义 N 元组的问题，例如 3，但无法为未指定的 N 生成元组.除了答案中的功能外，我还需要一个可以像 gen_tower<N> 这样使用的功能返回 tuple(v1,v2,...,vN) .

考虑使用可变参数编程计算阶乘的示例。我需要一个函数来计算阶乘 factorial<N>()对于任何 N , 除了能够写出任何特定的表达式 <1*2*3>手动。 (这就是为什么我询问可变参数编程以及 c++14 是否会使其更容易的原因。)

附言

纯粹出于个人兴趣，我希望这个序列能够实现一个可以从文件中读取 N 维数组的通用函数。我还不知 Prop 体怎么做，但我认为在第一步，我应该能够定义最终的 N维数组和中间 k k 的维数组来自 N-1至1 .我可以读取二维数组和 3 维。但是能读取任意维度的数组就好了。

Answer 1

不需要可变参数，递归 typedef足以在编译时生成这些类型。

---

是如何实现的？

1) 提供带有 2 个参数的模板: vector 元素类型 (T) 和所需的结构维度 (size_t N)。声明一个 typedef type :它将基于type的声明对于以深度 N-1 实例化的模板，因此递归。

template<typename T, size_t N>
struct VectorGenerator
{
    typedef std::vector< typename VectorGenerator<T, N-1>::type > type;
};

2) 提供终止递归的终止案例，这里是我们模板的特化，维度为 0，声明通常的 std::vector<T> 的类型.

template<typename T>
struct VectorGenerator<T, 0>
{
    typedef std::vector<T> type;
};

---

如何使用？

我们现在可以声明一个 vector v类型 VectorGenerator<T, N>::type :

VectorGenerator<double, 4>::type v; // v as a depth of 4 and handle double

但它的可读性和方便性都不是很高，而且非常冗长。让我们为我们的类型引入新名称。

这是 template aliasing 的完美案例, 使用 (C++11) using别名的关键字。我们有两种不同的别名方式:

1) 为特定的维度和类型声明一个别名，这里我们称它为 N=3 的 V3和 T=double :

using V3 = VectorGenerator<double, 3>::type;  // Alias

V3 v;                                         // Use the alias

或者，

2) 为特定类型声明模板别名，将维度作为模板参数:

template <size_t N> 
using V = typename VectorGenerator<double, N>::type;  // Alias

V<3> v;                                              // Use the Alias

---

最终代码示例:

template<typename T, size_t N>
struct VectorGenerator
{
    typedef std::vector< typename VectorGenerator<T, N-1>::type > type;
};

template<typename T>
struct VectorGenerator<T, 0>
{
    typedef std::vector<T> type;
};

// Alias for V3, V2 ... usage
using V3 = VectorGenerator<double, 3>::type;
using V2 = VectorGenerator<double, 2>::type;

// Alias for V <k> usage
template <size_t N> 
using V = typename VectorGenerator<double, N>::type;

int main() {

    V<3> v3;
    V<2> v2;
    v3.push_back(v2);
    return 0;
}

---

注意事项:

• 考虑 Boost MultiDimensional Array library .
• 我不确定你的最终目标是什么，但这很可能是矫枉过正。
• 至于您的第二次编辑，声明 tuple使用多个不同维度的 vector 现在很容易:

示例:

auto tower = std::tuple<V<1>, V<2>, V<3>>(v1, v2, v3);

对于多个“塔”的通用元组生成，@mpark 给出了 a working C++14 solution ，我在这里将其改编为我的代码示例:

template <typename T>
struct identity { using type = T; };

// Generate a tuple of towers by mapping index_sequence over gen_tower.
template <typename T, std::size_t... Is>
std::tuple<VectorGenerator<T, Is>...> gen_towers_impl(std::integer_sequence<Is...>);

// Make an index_sequence for N and use gen_towers_impl.
template <typename T, std::size_t N>
struct gen_towers
    : identity<decltype(gen_towers_impl<T>(std::make_index_sequence<N>()))> {};

// Convenience type aliases
template <typename T, std::size_t N>
using gen_towers_t = typename gen_towers<T, N>::type;

您将需要 -std=c++1y编译它(并包括 <utility> 和 <tuple> 头文件)

查看工作示例 here .