C++ 编译时生成一个遗漏的整数序列

答案和答案正是我所需要的。但是，我希望能够生成如下序列：

gen_seq<5, 2> // {0, 1, 3, 4}
gen_seq<3, 0> // {1, 2}
// optional behavior that would be useful for me:
gen_seq<4, 4> // {0, 1, 2, 3}

gen_seq/{0,1,3,4}
gen_seq/{1,2}
//对我有用的可选行为：
gen_seq/{0,1,2,3}

在示例中，我使用gen_-seq生成从0到N-1的序列，没有I。这不是强制性的，我也可以使用gen_-seq，其中N是序列的长度，I是缺失的索引或其他变量

我认为大部分问题已经在相关问题中得到了回答。然而，我无法真正理解如何为第二个参数合并“忽略此参数”条件

---

理想情况下，我希望坚持使用c++11特性，避免使用c++14。不过，使用c++14编写的优雅且可读性强的解决方案也可能非常有趣。

写下您的问题总是很棒的

我刚刚发现，我可以使用分治方法，不从0到N/2和N/2+1到N生成，而是在第一步中，从0到I-1和从I+1到N生成

这，我可以结合线性或日志深度生成方法。

---

现在我觉得问这个问题很愚蠢，但至少我不再被卡住了。

你可以使用以下方法：

#if 1 // Not in C++11 // make_index_sequence
#include <cstdint>

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

template <std::size_t N, std::size_t... Is>
struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};

template <std::size_t... Is>
struct make_index_sequence<0u, Is...> : index_sequence<Is...> { using type = index_sequence<Is...>; };

#endif // make_index_sequence

namespace detail
{
    template <typename Seq1, std::size_t Offset, typename Seq2> struct concat_seq;

    template <std::size_t ... Is1, std::size_t Offset, std::size_t ... Is2>
    struct concat_seq<index_sequence<Is1...>, Offset, index_sequence<Is2...>>
    {
        using type = index_sequence<Is1..., (Offset + Is2)...>;
    };
}

template <std::size_t N, std::size_t E>
using gen_seq = typename detail::concat_seq<typename make_index_sequence<E>::type, E + 1, typename make_index_sequence<(N > E) ? (N - E - 1) : 0>::type>::type;

static_assert(std::is_same<index_sequence<0, 1, 3, 4>, gen_seq<5, 2>>::value, "");
static_assert(std::is_same<index_sequence<1, 2>, gen_seq<3, 0>>::value, "");
static_assert(std::is_same<index_sequence<0, 1, 2, 3>, gen_seq<4, 4>>::value, "");

#如果1//不在C++11//中，则生成索引
#包括
模板结构索引_序列{}；
模板
结构make_index_序列：make_index_序列{}；
模板
结构make_index_sequence:index_sequence{using type=index_sequence；}；
#endif//make_index_序列
名称空间详细信息
{
模板结构concat_seq；
模板
结构混凝土
{
使用类型=索引\u序列；
};
}
模板
使用gen_seq=typename detail:：concat_seq:：type>：：type；
静态断言（std:：is_same:：value，“”）；
静态断言（std:：is_same:：value，“”）；
静态断言（std:：is_same:：value，“”）；

---

生成整数序列的简单线性方法通过添加一个专门化，涵盖被排除项的情况，非常适合排除特定项：

#include <iostream>

// general case, ignores X

template <int N, int X, int... vals>
struct gen_seq : gen_seq<N - 1, X, N - 1, vals...> { };

template <int X, int... vals>
struct gen_seq<0, X, vals...> { static constexpr int values[] = { vals... }; };

// specialisations when vals has had X prepended: remove X

template <int N, int X, int... vals>
struct gen_seq<N, X, X, vals...> : gen_seq<N, X, vals...> { };

template <int... vals>
struct gen_seq<0, 0, 0, vals...> : gen_seq<0, 0, vals...> { };

template <int X, int... vals>
constexpr int gen_seq<0, X, vals...>::values[];

int main() {
  for (auto i : gen_seq<5, 2>::values) std::cout << i << std::endl; // 0 1 3 4
  for (auto i : gen_seq<3, 0>::values) std::cout << i << std::endl; // 1 2
  for (auto i : gen_seq<4, 4>::values) std::cout << i << std::endl; // 0 1 2 3
}

#包括
//一般情况下，忽略X
模板
结构gen_seq:gen_seq{}；
模板
结构gen_seq{static constexpr int values[]={vals…}；}；
//VAL预先设置X时的专业化：删除X
模板
结构gen_seq:gen_seq{}；
模板
结构gen_seq:gen_seq{}；
模板
constexpr int gen_seq:：value[]；
int main（）{
对于（自动i:gen_seq:：values）std:：cout