Question

请考虑以下代码：

keyName = Word(pp.alphanums + '_')
unitDef = Suppress('(') + Word(alphanums + '^*/-._') + Suppress(')')
paramValueDef = SkipTo('*' | lineEnd)

paramDef = keyName('name') + pp.Optional(unitDef)('unit') + pp.Suppress(":" + pp.empty) + paramValueDef('value')

我希望有一个合并两个或更多static constexpr size_t Num {2}; struct S { std::array<size_t, Num> get () { return {1, 2}; } }; struct S1 : S {}; struct S2 : S {}; struct M { template <typename T> typename std::enable_if<std::is_same<T, S1>::value, S1>::type get () const { return S1 {}; } template <typename T> typename std::enable_if<std::is_same<T, S2>::value, S2>::type get () const { return S2 {}; } };个std::array的函数。

到目前为止，我结束了这样的事情：

std::array

我想拥有以下代码

template <typename Mode, typename... Rs, size_t... Ns>
std::array<size_t, sizeof... (Rs)*Num> get_array (const Mode& mode, Sequence::Sequence<Ns...>) {
    return {std::get<Ns> (mode.template get<Rs...> ().get ())...};
}

生成M m; auto x = get_array<M, S1, S2> (m, Sequence::Make<2> {});，内容为std::array<size_t, 4>。

{1, 2, 1, 2}和Sequence::Sequence为described here。

我知道在此上下文中放置Sequence::Make ...是不正确的（如果Rs为1，那么一切正常，sizeof... (Rs)并返回std::array<size_t, 2> ）但我不知道在哪里进行扩展，看起来像这样：

{1, 2}

当然std::get<0> (mode.template get<Rs[0]> ().get ()), std::get<1> (mode.template get<Rs[0]> ().get ()), std::get<0> (mode.template get<Rs[1]> ().get ()), std::get<1> (mode.template get<Rs[1]> ().get ());我指的是参数包中的第一个类型。

甚至可能吗？

Answer 1

假设我们正在使用Xeo's index sequence实施，我们可以这样做：

首先创建一个连接两个数组的函数。它接收数组，加上每个数组的索引序列（detail::seq是index_sequence类型）

template<class T, size_t N, size_t M, size_t... I, size_t... J>
std::array<T, N + M> concat(const std::array<T, N>& arr1, const std::array<T, M>& arr2, detail::seq<I...>, detail::seq<J...>)
{
     return {arr1[I]..., arr2[J]...};
}

接下来，请使用get_array功能调用此功能，但我们要将seq中通过main调用的template<class MODE, class... T, size_t... I> auto get_array(MODE m, detail::seq<I...>) ->decltype(concat(m.template get<T>().get()..., detail::seq<I...>{}, detail::seq<I...>{})){ return concat(m.template get<T>().get()..., detail::seq<I...>{}, detail::seq<I...>{}); }加倍：

main

M m; auto x = get_array<M, S1, S2>(m, detail::gen_seq<2>{});中的调用与您的代码中的调用类似：

detail::gen_seq

make_index_sequence是Xeo所拥有的unsigned的实现。

Live Demo

请注意，我在Xeo的索引序列impl中将size_t替换为seq。

在C ++ 14中，我们不需要实现gen_seq或-> decltype()，并且在我们的功能之后我们也不需要追踪sudo apt install libcanberra-gtk-module。< / p>

在C ++ 17中，使用折叠表达式来概括任意数量的数组的连接会更容易。

Answer 2

是的，这可以通过标准的index_sequence技巧来完成：

template <class T, std::size_t N1, std::size_t N2, std::size_t ... Is, std::size_t ... Js>
std::array<T, N1 + N2> merge_impl(const std::array<T, N1>& a1,
                                  const std::array<T, N2>& a2, 
                                  std::index_sequence<Is...>,
                                  std::index_sequence<Js...>) {
    return {a1[Is]..., a2[Js]...};
}

template <class T, std::size_t N1, std::size_t N2>
std::array<T, N1 + N2> merge(const std::array<T, N1>& a1, const std::array<T, N2>& a2) {
    return merge_impl(a1, a2,
                      std::make_index_sequence<N1>{}, 
                      std::make_index_sequence<N2>{});
}

index_sequence仅在14个标准中，但可以在11中轻松实现;有很多资源（包括在SO上）描述了如何这样做（编辑：它基本上等同于你的Sequence东西，也可以习惯它们的标准名称）。实例：http://coliru.stacked-crooked.com/a/54dce4a695357359。

Answer 3

首先，这基本上要求连接任意数量的数组。这与连接任意数量的元组非常相似，即使在C ++ 11中也存在标准库函数：std::tuple_cat()。这让我们几乎到了那里：

template <class... Ts, class M>
auto get_array(M m) -> decltype(std::tuple_cat(m.template get<Ts>()...)) {
    return std::tuple_cat(m.template get<Ts>()...);
}

请注意，我翻转了模板参数，因此这只是get_array<T1, T2>(m)而不是必须写get_array<M, T1, T2>(m)。

现在问题是，我们如何写array_cat？我们只使用tuple_cat并将生成的tuple转换为array。假设index_sequence的实现可用（无论如何，这都是您在集合中想要的）：

template <class T, class... Ts, size_t... Is>
std::array<T, sizeof...(Ts)+1> to_array_impl(std::tuple<T, Ts...>&& tup,
                                             std::index_sequence<Is...> ) {
    return {{std::get<Is>(std::move(tup))...}};
}

template <class T, class... Ts>
std::array<T, sizeof...(Ts)+1> to_array(std::tuple<T, Ts...>&& tup) {
    return to_array_impl(std::move(tup), std::index_sequence_for<T, Ts...>());
}

template <class... Tuples>
auto array_cat(Tuples&&... tuples) -> decltype(to_array(std::tuple_cat(std::forward<Tuples>(tuples)...))) {
    return to_array(std::tuple_cat(std::forward<Tuples>(tuples)...));
}

这会给你：

template <class... Ts, class M>
auto get_array(M m) -> decltype(array_cat(m.template get<Ts>()...)) {
    return array_cat(m.template get<Ts>()...);
}

处理任意多种类型。

Answer 4

所以这里是任意数量的相同类型的数组。我们基本上实现了tuple_cat的高度限制性版本，因为数组中的元素数量相同，因此变得非常容易。我使用了几个C ++ 14和17库特性，这些特性在C ++ 11中都很容易实现。

template<class, size_t> struct div_sequence;
template<size_t...Is, size_t Divisor>
struct div_sequence<std::index_sequence<Is...>, Divisor>
{
   using quot = std::index_sequence<Is / Divisor...>;
   using rem = std::index_sequence<Is % Divisor...>;
};


template<class T, size_t...Ns, size_t...Is, class ToA>
std::array<T, sizeof...(Ns)> array_cat_impl(std::index_sequence<Ns...>,
                                            std::index_sequence<Is...>,
                                            ToA&& t) 
{
    // NB: get gives you perfect forwarding; [] doesn't.
    return {std::get<Is>(std::get<Ns>(std::forward<ToA>(t)))... }; 
}

template<class Array, class... Arrays,
         class VT = typename std::decay_t<Array>::value_type,
         size_t S = std::tuple_size<std::decay_t<Array>>::value,
         size_t N = S * (1 + sizeof...(Arrays))>
std::array<VT, N> array_cat(Array&& a1, Arrays&&... as) 
{
     static_assert(std::conjunction_v<std::is_same<std::decay_t<Array>,
                                                   std::decay_t<Arrays>>...
                                      >, "Array type mismatch");

     using ind_seq = typename div_sequence<std::make_index_sequence<N>, S>::rem;
     using arr_seq = typename div_sequence<std::make_index_sequence<N>, S>::quot;
     return array_cat_impl<VT>(arr_seq(), ind_seq(), 
                               std::forward_as_tuple(std::forward<Array>(a1),
                                                     std::forward<Arrays>(as)...)
                               );
}

我们也可以重用tuple_cat机制，就像在@ Barry的回答中一样。为了避免潜在的QoI问题，避免依赖扩展和额外的动作，我们不希望直接tuple_cat std::array。相反，我们首先将数组转换为引用元组。

template<class TupleLike, size_t... Is>
auto as_tuple_ref(TupleLike&& t, std::index_sequence<Is...>)
    -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<TupleLike>(t))...))
{
    return std::forward_as_tuple(std::get<Is>(std::forward<TupleLike>(t))...);
}

template<class TupleLike,
         size_t S = std::tuple_size<std::decay_t<TupleLike>>::value >
auto as_tuple_ref(TupleLike&& t)
    -> decltype(as_tuple_ref(std::forward<TupleLike>(t), std::make_index_sequence<S>()))
{
    return as_tuple_ref(std::forward<TupleLike>(t), std::make_index_sequence<S>());
}

然后我们可以将tuple_cat＆＃39; d引用转换回数组：

template <class R1, class...Rs, size_t... Is>
std::array<std::decay_t<R1>, sizeof...(Is)> 
   to_array(std::tuple<R1, Rs...> t, std::index_sequence<Is...>) 
{
   return { std::get<Is>(std::move(t))... };
}

template <class R1, class...Rs>
std::array<std::decay_t<R1>, sizeof...(Rs) + 1> to_array(std::tuple<R1, Rs...> t) 
{
   static_assert(std::conjunction_v<std::is_same<std::decay_t<R1>, std::decay_t<Rs>>...>,
                 "Array element type mismatch");
   return to_array(t, std::make_index_sequence<sizeof...(Rs) + 1>());
}

最后，array_cat本身就是

template <class... Arrays>
auto array_cat(Arrays&&... arrays) 
    -> decltype(to_array(std::tuple_cat(as_tuple_ref(std::forward<Arrays>(arrays))...))) 
{
    return to_array(std::tuple_cat(as_tuple_ref(std::forward<Arrays>(arrays))...));
}

任何体面的优化器都应该很难优化参考的中间元组。

展开两个参数包

4 个答案:

Live Demo