Decrement template parameter inside a fold expression

Question

Consider the following code:

template<typename...>
struct C
{ /* ... */ };

template<typename T, unsigned N>
struct B
{
    using type = /* ... */;
};

template<size_t N, typename... Ts>
struct A
{
    using type = C<typename B<Ts, N-->::type...>; // decrement N sizeof...(Ts) times
};

So for example

typename A<5, int, long, void>::type

expands to

C<typename B<int, 5>::type, typename B<long, 4>::type, typename B<void, 3>::type>

Since N is a const value, this code does not compile. Is there any other way?

It's a constant expression. It's like trying to do `5--`; it's nonsense. — Nicol Bolas, Jan 09 '20 at 16:16
What are you trying to do? What is the actual problem (if any) you need to solve? Why do you need to decrement the value? — Some programmer dude, Jan 09 '20 at 16:17
please include the error message in the question and please show real code (preferably [mcve]). I find it highly confusing to have `...` from folds and `...` to indicate missing code in the same snippet — 463035818_is_not_an_ai, Jan 09 '20 at 16:17
Sounds like you want a [reverse integer sequence](https://stackoverflow.com/questions/51408771/c-reversed-integer-sequence-implementation) — NathanOliver, Jan 09 '20 at 16:17
@formerlyknownas_463035818 They want it to count down, which that wont do. — NathanOliver, Jan 09 '20 at 16:20
@NathanOliver: I think I see what you mean about "count down" now. OP does want a reversed integer sequence if that's the case — AndyG, Jan 09 '20 at 16:30

Caleth · Accepted Answer · 2020-01-09T17:02:41.447

9

Subtract a std::index_sequence from N

namespace detail {
    template<size_t N, typename... Ts, size_t... Is>
    C<typename B<Ts, N - Is>::type...> A_impl(std::index_sequence<Is...>);
}

template<size_t N, typename... Ts>
struct A
{
    using type = decltype(detail::A_impl<N, Ts...>(std::index_sequence_for<Ts...>{}));
};

edited Jan 09 '20 at 17:02

answered Jan 09 '20 at 16:31

Caleth

52,200
2
44
75

1

Looks like a charm. – Evg Jan 09 '20 at 17:05
Wow this is very similar to what I came up with, even the template argument name for the non-type template `size_t...` – AndyG Jan 09 '20 at 17:35

score 2 · Answer 2 · answered Jan 09 '20 at 17:30

You can do it with a not-actually-defined-or-invoked templated static constexpr helper function:

template<size_t N, typename... Ts>
struct A
{
    template<size_t... Is>
    static constexpr auto type_getter(std::index_sequence<Is...>) -> C<typename B<Ts, N-Is>::type...>;
    using type = decltype(type_getter(std::index_sequence_for<Ts...>{}));
};

Decrement template parameter inside a fold expression

2 Answers2

Demo