Question

所以有人问了一个问题然后将其删除了，但我觉得这是一个有趣的挑战。

他们有这种奇怪的类型，并且遇到了Concat和Range可以转换为Sequences但不是Sequences的问题（出于显而易见的原因）

template<unsigned... Is> struct Sequence{};    

template<typename... Is> struct Concat{};
template<unsigned... Is> struct Concat<Sequence<Is...>> : public Sequence<Is...> {};
template<unsigned... Is, unsigned... Js, typename... Rest>
struct Concat<Sequence<Is...>, Sequence<Js...>, Rest...>
   : Concat<Sequence<Is..., Js...>, Rest...> {};

所以我认为做正确的事情是一个有趣的挑战，使所有类型都相同。

所以我在Concat的第一次传递遇到了意想不到的问题......究竟如何提取序列的模板参数？我最终使用了以下功能：

template <unsigned... Is,unsigned... Js>
constexpr auto concat_results(Sequence<Is...>,Sequence<Js...>) -> Sequence<Is...,Js...>
{
  return Sequence<Is...,Js...>();
}


template <typename seq1,typename seq2>
using Concat = decltype(concat_results(seq1(),seq2()));

奇怪的是，我认为这是宣布它的最短路，尽管它有点奇怪。但是，concat_results可能是有用的（在序列的引用上），并且类型在其他地方可能是有用的。有人有更好的方法吗？

接下来是范围，我使用递归的struct helper：

template <unsigned N>
struct nrange_helper
{
  using Range = Concat<typename nrange_helper<N-1>::Range,Sequence<N>>;
};

template <>
struct nrange_helper<0>
{
  using Range = Sequence<0>;
};

template <unsigned N>
using Range = typename nrange_helper<N>::Range;

再次，它很奇怪，但它的作用......但我觉得应该有更好的方法。有人有吗？

Answer 1

注意：请查看std::integer_sequence，其专长index_sequence及其make_index_sequence和index_sequence_for设施。

如果您想自己声明它们，通常会使用内部类型：

template <typename, typename> struct Concat;

template <unsigned... Is, unsigned... Js>
struct Concat<Sequence<Is...>,Sequence<Js...>> {
    using type = Sequence<Is..., Js...>;
};

template <unsigned N>
struct Range {
    using type = typename Concat<typename Range<N-1>::type, Sequence<N>>::type;
};

template <> struct Range<0> { using type = Sequence<0>; };

当然可以将模板别名组合成较短的最终形式：

 template <typename, typename> struct ConcatH;

template <unsigned... Is, unsigned... Js>
struct ConcatH<Sequence<Is...>,Sequence<Js...>> {
    using type = Sequence<Is..., Js...>;
};

template <typename L, typename R>
using Concat = typename ConcatH<L, R>::type;

和

template <unsigned N>
struct RangeH {
    using type = Concat<typename RangeH<N-1>::type, Sequence<N>>;
};

template <> struct RangeH<0> { using type = Sequence<0>; };

template <unsigned N>
using Range = typename RangeH<N>::type;

然而，确实，这有点冗长。不过，这里几乎没有什么结果：

基线声明
专业化（结束递归或限制为“有趣”类型）
别名声明

另一方面，它只写了一次。

如何实现递归“使用”/提取模板参数

1 个答案: