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

How to create custom integer sequence in C++

本文关键字：自定义 整数 创建 C++      更新时间：2023-10-16

我有这样的函数：

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，以便该序列转换为类似'1，value1，2，value2，3，value3'的序列。因此，每个值都遵循其基本序列中的数字。但我无法创建这个"敏捷代码"来在编译阶段在这两种状态之间转换序列。

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

以下示例应适用于C++11

---编辑---

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

不需要std::index_sequence（可以使用平凡的struct indSeq）或std::make_index_sequence（可以使用sizeof...(I)逐步构建索引序列）；不再需要CCD_ 6。

#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;
 }

抱歉我英语不好。

这里有一个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 );
}

实时示例

它目前是基于零的，但+1在正确的位置可以很容易地解决这个问题。此外，它还创建了一个中间std::tuple，其中引用了这些值，如果性能是一个问题，可能会有更好的选项，但由于您没有使用std::forward，我认为对性能的小影响可能是可以接受的。

相关文章：