Question

我们说我们有以下类型

template <bool... Values>
struct foo{};

我想从constexpr数组bool tab[N]创建一个可变参数模板。换句话说，我想做类似的事情：

constexpr bool tab[3] = {true,false,true};
using ty1 = foo<tab[0], tab[1], tab[2]>;

但我想以编程方式进行。目前，我已尝试过以下方法：

template <std::size_t N, std::size_t... I>
auto
mk_foo_ty(const bool (&tab)[N], std::index_sequence<I...>)
{
  // error: template argument for template type parameter must be a type
  return foo<tab[I]...>{};
}

// error (see mk_foo_ty)
using ty2 = decltype(mk_ty(tab, std::make_index_sequence<3>{}));

// error: expected '(' for function-style cast or type construction
using ty3 = foo<(tab[std::make_index_sequence<3>])...>;

我甚至不确定它是否可能。也许诉诸于像Boost.Preprocessor这样的东西，但我不喜欢这个想法。那么，有没有人有想法？谢谢！

修改

我一方面有一个constexpr方形矩阵的框架，可以在编译时使用xor，否定等创建。

另一方面，我有一个模板框架，它使用布尔值作为参数，使用在可变参数模板中编码的信息静态创建操作。

我的目标是弥合这两个框架之间的差距。因此，我无法使用硬编码解决方案。

编辑2

我发现这个question有同样的问题和一个很好的答案，它非常接近T.C.'s one（使用指针）。 extern链接也非常重要。

然而，我意识到我忘记了一个关键因素。我的bool数组包含在matrix结构中，以便能够重载运算符^，|等等：

template <std::size_t N>
struct matrix
{
  const bool data_[N*N];

  template<typename... Values>
  constexpr matrix(Values... values) noexcept
    : data_{static_cast<bool>(values)...}
  {}

  constexpr bool operator [](std::size_t index) const noexcept
  {
    return data_[index];
  }
}

因此，如果我们应用T.C的解决方案：

template<std::size_t N, const bool (&Tab)[N], class>
struct ty1_helper;

template<std::size_t N, const bool (&Tab)[N], std::size_t... Is>
struct ty1_helper<N, Tab, std::index_sequence<Is...>>
{
  using type = foo<Tab[Is]...>;
};

template<std::size_t N, const bool (&Tab)[N]>
using ty1 = typename ty1_helper<N, Tab, std::make_index_sequence<N>>::type;

编译器抱怨传递非类型参数：

// error: non-type template argument does not refer to any declaration
//        using t = make_output_template<m.data_, std::make_index_sequence<3>>;
//                                       ^~~~~~~
using t = ty1<3, m.data_>;

Answer 1

我在上面的评论中所做的方式，使用具有外部链接的全局constexpr变量（由于GCC的不一致外部链接要求，参见bug 52036所必需的），可能会在链接上引人注目时间，如果你把它放在一个标题中，并在不同的翻译单位中包含标题。对一个翻译单元有利的解决方案并不是一个很好的解决方案。一种解决方法是将矩阵存储为类的静态数据成员。

struct matrix_holder {
    static constexpr matrix<2> mat = {true, false, true, false};
};

template<std::size_t N, const matrix<N> &Mat, class> 
struct ty1_helper;

template<std::size_t N, const matrix<N> &Mat, std::size_t... Is>
struct ty1_helper<N, Mat, std::index_sequence<Is...>> { 
    using type = foo<Mat[Is]...>; 
};

template<std::size_t N, const matrix<N> &Mat>
using ty1 = typename ty1_helper<N, Mat, std::make_index_sequence<N*N>>::type;

static_assert(std::is_same<ty1<2, matrix_holder::mat>,
                           foo<true, false, true, false>>::value, "Oops");

Demo。此外，由于在matrix_holder::mat中使用ty1<2, matrix_holder::mat>计算为使用odr，为了完全符合，您应该提供一个定义：

constexpr matrix<2> matrix_holder::mat;

从constexpr数组创建可变参数模板

1 个答案: