Question

我的功能如下：

template <typename ... Types>
void foo(const Types & ... values)
{
    // expected that 'values' is sequence like
    // '1, customvalue1, 2, customvalue2, 3,...'
}

第二个功能：

template <typename ... Types>
void bar(const Types & ... values)
{
    // where 'values' are any variables
    // some magic here
    foo((int_seq<sizeof...(Types)>, values)...);
}

我想将任何变量序列传递给 bar ，以便此序列转换为＆＃39; 1，value1,2，value2,3等序列，值3＆＃39; 即可。因此，每个值都遵循基本序列中的数字。但我不能创建这个＆＃39;魔法代码＆＃39; 来在这两个状态之间的编译阶段转换序列。

Answer 1

这是一个C ++ 14解决方案，但所有必要的库部分也可以用C ++ 11编写。

#include <iostream>
#include <tuple>
#include <utility>

template <typename ... Types>
void foo(const Types & ... values)
{
    using swallow = bool[];
    (void)swallow{ (std::cout << values << std::endl,false)... };
}

template <std::size_t N, bool = (N%2==0)>
struct pick {
    template<typename... Types>
    static std::size_t get(const std::tuple<Types...>&) { return N/2; }
};

template <std::size_t N>
struct pick<N,false> {
    template<typename... Types>
    static auto get(const std::tuple<Types...>& t) { return std::get<N/2>(t); }
};

template <std::size_t... Indices, typename ... Types>
void bar2(const std::index_sequence<Indices...>, const Types & ... values)
{
    auto x = std::tie(values...);
    foo(pick<Indices>::get(x)...);
}

template <typename ... Types>
void bar(const Types & ... values)
{
    bar2(std::index_sequence_for<Types...,Types...>(), values...);
}

int main()
{
    bar( "Hallo", 42, 1.23 );
}

Live example

它目前是从零开始的，但正确位置的+1可以轻松解决这个问题。此外，它会创建一个中间std::tuple，其中包含对值的引用，如果性能问题，可能存在更好的选项，但由于您没有使用std::forward，我认为可能会产生较小的性能影响对你而言。

Answer 2

不是很优雅，但使用元组，std::tie等等......

以下示例适用于C ++ 11

---编辑---

我的第一个例子是修改和统一的（没有C ++ 14元素的C ++ 11）。

不需要std::index_sequence（可以使用普通struct indSeq）或std::make_index_sequence（索引序列可以使用sizeof...(I)逐步构建）;不再需要qux()。

#include <tuple>
#include <iostream>


void foo ()
 { }

template <typename T0, typename ... Types>
void foo (const T0 & v0, const Types & ... values)
 {
   std::cout << "-- " << v0 << std::endl;

   foo(values...);
 }


template <std::size_t ...>
struct indSeq
 { };

template <std::size_t ... Is, typename ... Ts1>
void baz (std::size_t, const indSeq<Is...> &, const std::tuple<Ts1...> & t)
 { foo(std::get<Is>(t)...); }

template <std::size_t ... Is, typename ... Ts1, typename T0, typename ... Ts2>
void baz (std::size_t n, const indSeq<Is...> &, const std::tuple<Ts1...> & t,
          const T0 & v0, const Ts2 & ... vs)
 { baz(n+1U, indSeq<Is..., sizeof...(Is), sizeof...(Is)+1U>(),
       std::tuple_cat(t, std::tie(n), std::tie(v0)), vs...); }

template <typename ... Types>
void bar (const Types & ... values)
 { baz (1U, indSeq<>(), std::tuple<>(), values...); }

int main()
 {
   bar(11, 22L, "33", 44.44);
   return 0;
 }

p.s：抱歉我的英语不好。

如何在C ++中创建自定义整数序列

2 个答案: