前言
之前翻cpp-reference翻到一个有趣的东西：
其中有一条
template<class T, T N>
using make_integer_sequence = std::integer_sequence<T, /* a sequence 0, 1, 2, ..., N-1 */ >;
起初没有仔细想，以为这种将一个参数N拆出N个元函数参数的效果是靠编译器开洞实现的，像std::declval那样，只有申明没有定义，后来在某个应用场景下用到了这玩意，又仔细考虑了一下，发现这玩意其实是可以实现的，下面给一个简单的实现。
正文
首先定义sequence
template<size_t...I>
struct seq {
using type = seq;
};
然后是concat，用以将两个sequence拆包再拼起来，因为处理目标是实现make_index_sequence<N>，所以这里和一般的concat不太一样，直接把1到N-1的计算也放进去了
template<class... I>
struct concat;
template<size_t L, size_t...H>
struct concat<seq<L>, seq<H...>> : public seq<L, (H + 1)...> {
};
最后是make
template<size_t N>
struct make : public concat<seq<0>, typename make<N-1>::type> {
};
template<>
struct make<1> : public seq<0> {
};
template<>
struct make<0> : public seq<> {
};
测试一下：
template<size_t N, size_t F, size_t...I>
constexpr size_t get(seq<F, I...> q) {
if constexpr (N == 0) {
return F;
} else {
return get<N - 1>(seq<I...>{});
}
}
void make_test() {
auto seq = make<4>{};
static_assert(get<0>(seq) == 0, "");
static_assert(get<1>(seq) == 1, "");
static_assert(get<2>(seq) == 2, "");
static_assert(get<3>(seq) == 3, "");
}
简单的使用
C++标准给出这样一个东西肯定是有用的，那么怎么用呢？最简单的可以用来迭代。
比如你有一个函数，作用是将传入的tuple的每一个元素加上1再返回
template<class... TList>
std::tuple<TList...> succ(std::tuple<TList...> tup) {
// how to add it?
}
有了make_sequence之后你可以这样：
template<class Sequence>
struct succ_impl;
template<size_t...I>
struct succ_impl<seq<I...>> {
template<class...TList>
static constexpr decltype(auto) apply(std::tuple<TList...> arg) {
return std::make_tuple( (std::get<I>(arg) + 1)... );
}
};
template<class... TList>
constexpr std::tuple<TList...> succ(std::tuple<TList...> arg) {
return succ_impl<typename make<sizeof...(TList)>::type>::apply(arg);
}
简单的测试一下：
void succ_test() {
constexpr std::tuple<int, int, int, int> tup(1, 2, 0, 4);
constexpr auto new_tup = succ(tup);
static_assert(std::get<0>(new_tup) == 2, "");
static_assert(std::get<1>(new_tup) == 3, "");
static_assert(std::get<2>(new_tup) == 1, "");
static_assert(std::get<3>(new_tup) == 5, "");
}
