将模板参数转换为逗号分隔的模板参数列表

Question

如果标题具有误导性或之前已经回答过这个问题，请道歉。

我正在使用Eigen的Tensor模块，特别是Eigen::TensorFixedSize类，因为我知道编译时的形状。

基本上，因为这是一个洛伦兹问题，一个等级2张量就像，

Eigen::TensorFixedSize<double, Eigen::Sizes<4,4>> t;

等级-3张量，

Eigen::TensorFixedSize<double, Eigen::Sizes<4,4,4>> t;

等等。

我想编写一个能够根据排名初始化张量的类。在伪代码中

template<typename RANK>
 class Foo
 {
  public:
   ...
  private:
   Eigen::TensorFixedSize<double, Eigen::Sizes<4,4,4,...,RANK times>> _t;
 }

以某种方式转换模板参数

<2> --> <4,4>

<3> --> <4,4,4>

在<N>中的任意unsigned int。

这有可能吗？

Answer 1

对。

template <class RankIdx>
struct TensorForRank;

template <std::size_t... RankIdx>
struct TensorForRank<std::index_sequence<RankIdx...>> {
    using type = Eigen::TensorFixedSize<double, Eigen::Sizes<(void(RankIdx), 4)...>>;
};

template <std::size_t Rank>
using TensorForRank_t = typename TensorForRank<std::make_index_sequence<Rank>>::type;

用于：

template<std::size_t Rank>
class Foo
{
    // ...
private:
    TensorForRank_t<Rank> _t;
};

See it live on Wandbox（占位符test<...>模板作为Eigen不可用）

Answer 2

Quentin's answer非常好，我会选择。

唯一的缺点是“无用”生成索引序列[0,1,2，...]，我们忽略它们的值，并替换我们自己的值。

如果我们想直接创建重复值，我们可以编写自己的生成器代码（这更详细）：

首先创建一个可以通过别名std::size_t来保存多个std::integer_sequence值的类型：

template<std::size_t... vals>
using value_sequence = std::integer_sequence<std::size_t, vals...>;

目标是最终创建一个value_sequence<4, 4, 4>，然后使用这些4s实例化Eigen::Sizes。

接下来我们需要做的是连接两个序列，因为我们要像这样构建它：

concat(value_sequence<4>, value_sequence<4>) --> value_sequence<4, 4>

我们可以通过接受两个value_sequence类型的stub方法来执行此操作并返回连接结果。请注意，我们不会为此方法编写定义;我们只是利用类型系统编写的代码少于模板专业化所需的代码：

template<std::size_t... lhs, std::size_t... rhs>
constexpr auto concat(value_sequence<lhs...>, value_sequence<rhs...>) -> value_sequence<lhs..., rhs...>;

在这一点上，我们有足够的机器来创建一个value_sequence<4,4,4>，所以现在我们需要一种方法来指示我们希望使用的值（4）和重复它的次数（3）来生成它：

template<std::size_t value, std::size_t num_repeats>
struct repeated_value
{
    using left_sequence = value_sequence<value>;
    using right_sequence = typename repeated_value<value, num_repeats-1>::type;
    using type = decltype(concat(left_sequence{}, right_sequence{}));
};

repeated_value<4, 3>::type生产value_sequence<4, 4, 4>。

由于repeated_value<...>::type是递归的，我们需要通过部分特化提供基本情况：

template<std::size_t value>
struct repeated_value<value, 1>
{
    using type = value_sequence<value>;
};

大。剩下的就是我们接受Eigen::Sizes类和value_sequence<4, 4, 4>类型，并生产Eigen::Sizes<4, 4, 4>。

我们可以再次使用部分模板专业化：

template<template<std::size_t...> class T, class...>
struct InstantiateWithRepeatedVals;

template<template<std::size_t...> class T, std::size_t... vals>
struct InstantiateWithRepeatedVals<T, value_sequence<vals...>> 
{
    using type = T<vals...>;
};

那个！投入一些助手使其更容易使用，我们已经完成了：

template<std::size_t value, std::size_t num_repeats>
using repeated_value_t = typename repeated_value<value, num_repeats>::type;

template<template<std::size_t...> class T, std::size_t Value, std::size_t N>
using InstantiateWithRepeatedVals_t = typename InstantiateWithRepeatedVals<T, repeated_value_t<Value, N>>::type;

现在我们可以像这样使用它：

using my_type = InstantiateWithRepeatedVals_t<EigenSizes, 4, 3>;
static_assert(std::is_same_v<my_type, EigenSizes<4, 4, 4>>);

Live Demo