{"id":103903,"date":"2020-06-25T07:00:00","date_gmt":"2020-06-25T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=103890"},"modified":"2020-07-02T06:50:16","modified_gmt":"2020-07-02T13:50:16","slug":"20200625-00-2","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20200625-00\/?p=103903","title":{"rendered":"Mundane std::tuple tricks: Creating interesting index sequences"},"content":{"rendered":"

We saw last time that manipulating tuples boils down to the index_sequence<\/code><\/a>. The problem is that the C++ standard library doesn’t provide very much in the way of helpers to manipulate these index sequences.<\/p>\n

The only ones that come with the standard library are make_integer_sequence<\/code>, a helper for generating the integer sequence 0, 1, 2, \u2026, N-1<\/code>, and its close relative make_index_sequence<\/code>, which does the same thing for size_t<\/code>.<\/p>\n

Note that the template parameter to make_index_sequence<\/code> is the size of the resulting index sequence, not the highest value in the index sequence. The highest value is one less than the size since the sequence starts at zero.<\/p>\n

Even with only index sequences that start at zero, we can do something interesting.<\/p>\n

template<typename Tuple>\r\nauto remove_last(Tuple&& tuple)\r\n{\r\n  constexpr auto size = std::tuple_size_v<Tuple>;\r\n  using indices = std::make_index_sequence<size-1>;\r\n  return select_tuple(std::forward<Tuple>(tuple), indices{});\r\n}\r\n<\/pre>\n
The remove_last<\/code> function removes the last element from the tuple and returns what’s left. We do this by extracting the size of the source tuple, subtracting one, and using that to generate a new index sequence that goes from 0 to size<\/code> \u2212 2, for a total of size<\/code> \u2212 1 elements.<\/p>\n
Okay, but what about other index sequences? We’ll have to build those ourselves.<\/p>\n
template<std::size_t N, typename Seq> struct offset_sequence;\r\n\r\ntemplate<std::size_t N, std::size_t... Ints>\r\nstruct offset_sequence<N, std::index_sequence<Ints...>>\r\n{\r\n using type = std::index_sequence<Ints + N...>;\r\n};\r\ntemplate<std::size_t N, typename Seq>\r\nusing offset_sequence_t = typename offset_sequence<N, Seq>::type;\r\n\r\n\/\/ example = index_sequence<3, 4, 5, 6>\r\nusing example = offset_sequence_t<3, std::make_index_sequence<4>>;\r\n<\/pre>\n
To offset an index sequence, we generate a new index sequence whose integers are the old integers plus the provided offset value N<\/var>. The magic happens in the template parameter pack expansion:<\/p>\n
 using type = std::index_sequence<Ints + N...>;\r\n<\/pre>\n
This takes each of the integers in the original index sequence, adds N<\/var> to each one, and uses the results to build a new index sequence.<\/p>\n
Now we can remove the first<\/i> element from the tuple.<\/p>\n
template<typename Tuple>\r\nauto remove_first(Tuple&& tuple)\r\n{\r\n  constexpr auto size = std::tuple_size_v<Tuple>;\r\n  using indices = offset_sequence_t<1,\r\n                    std::make_index_sequence<size-1>>;\r\n  return select_tuple(std::forward<Tuple>(tuple), indices{});\r\n}\r\n<\/pre>\n
And in fact, we can remove the N<\/var>th element.<\/p>\n
template<std::size_t N, typename Tuple>\r\nauto remove_Nth(Tuple&& tuple)\r\n{\r\n  constexpr auto size = std::tuple_size_v<Tuple>;\r\n  using first = std::make_index_sequence<N>;\r\n  using rest = offset_sequence_t<N+1,\r\n                std::make_index_sequence<size-N-1>>;\r\n  return std::tuple_cat(\r\n    select_tuple(std::forward<Tuple>(tuple), first{}),\r\n    select_tuple(std::forward<Tuple>(tuple), rest{}));\r\n}\r\n<\/pre>\n
What we want to do is extract the first N<\/var> elements, skip element N<\/var>, and then extract elements N<\/var> + 1 to the end.<\/p>\n
Extracting the first N<\/var> is easy: We select from the index sequence that goes from 0 to N<\/var> \u2212 1.<\/p>\n
Extracting the rest of the elements is trickier: We want to start at N<\/var> + 1 and continue until size<\/code> \u2212 1, for a length of (size<\/code> \u2212 1) \u2212 (N<\/var> + 1) + 1 = size<\/code> \u2212 N<\/var> \u2212 1. We generate an index sequence of length size<\/code> \u2212 N<\/var> \u2212 1 (starting at zero), then add N<\/var> + 1 to each element, to bring us to the desired sequence.<\/p>\n
We call select_tuple<\/code> twice, once to get the front part, once to get the back part, and then use tuple_cat<\/code> to put them together.<\/p>\n
Another way to do this is with a single selection. For that, we need a way to concatenate two index sequences.<\/p>\n
template<typename Seq1, typename Seq> struct cat_sequence;\r\n\r\ntemplate<std::size_t... Ints1, std::size_t... Ints2>\r\nstruct cat_sequence<std::index_sequence<Ints1...>,\r\n                    std::index_sequence<Ints2...>>\r\n{\r\n using type = std::index_sequence<Ints1..., Ints2...>;\r\n};\r\ntemplate<typename Seq1, typename Seq2>\r\nusing cat_sequence_t = typename cat_sequence<Seq1, Seq2>::type;\r\n\r\n\/\/ example = index_sequence<3, 1, 4, 1, 5, 9>\r\nusing example = cat_sequence_t<std::index_sequence<3, 1, 4>,\r\n                               std::index_sequence<1, 5, 9>>;\r\n<\/pre>\n
The magic happens at<\/p>\n
 using type = std::index_sequence<Ints1..., Ints2...>;\r\n<\/pre>\n
which takes the two sequences and places them one after the other into a single index sequence.<\/p>\n
We can now use this alternate formulation:<\/p>\n
template<std::size_t N, typename Tuple>\r\nauto remove_Nth(Tuple&& tuple)\r\n{\r\n  constexpr auto size = std::tuple_size_v<Tuple>;\r\n  using first = std::make_index_sequence<N>;\r\n  using rest = offset_sequence_t<N+1,\r\n                std::make_index_sequence<size-N-1>>;\r\n  using indices = cat_sequence_t<first, rest>;\r\n  return select_tuple(std::forward<Tuple>(tuple), indices{});<\/span>\r\n}\r\n<\/pre>\n
We’ll continue manipulating index sequences next time.<\/p>\n","protected":false},"excerpt":{"rendered":"
Building our own little template language.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-103903","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Building our own little template language.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/103903","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=103903"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/103903\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=103903"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=103903"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=103903"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}