Variadic Template Recursion

Question

I am trying to use recursion to solve this problem where if i call

decimal<0,0,1>();

i should get the decimal number (4 in this case).

I am trying to use recursion with variadic templates but cannot get it to work.

Here's my code;

template<>
int decimal(){
    return 0;
}



template<bool a,bool...pack>
int decimal(){
        cout<<a<<"called"<<endl;
        return a*2 + decimal<pack...>();
};

int main(int argc, char *argv[]){
    cout<<decimal<0,0,1>()<<endl;
    return 0;
}

What would be the best way to solve this?

Possible duplicate of [recursive variadic template to print out the contents of a parameter pack](http://stackoverflow.com/questions/7124969/recursive-variadic-template-to-print-out-the-contents-of-a-parameter-pack) — Vittorio Romeo, Oct 14 '16 at 13:03
When asking "why does this code not work, and how do I fix it", include error messages (what went wrong) as well as what you expect. — Yakk - Adam Nevraumont, Oct 14 '16 at 13:12

score 3 · Answer 1 · answered Oct 14 '16 at 13:17

template<typename = void>
int decimal(){
    return 0;
}

template<bool a,bool...pack>
int decimal(){
        cout<<a<<"called"<<endl;
        return a + 2*decimal<pack...>();
};

The problem was with the recursive case, where it expects to be able to call decltype<>(). That is what I have defined in the first overload above. You can essentially ignore the typename=void, the is just necessary to allow the first one to compile.

max66 · Answer 2 · 2016-10-14T13:20:02.133

A possible solution can be the use of a constexpr function (so you can use it's values it's value run-time, when appropriate) where the values are argument of the function.

Something like

#include <iostream>

constexpr int decimal ()
 { return 0; }

template <typename T, typename ... packT>
constexpr int decimal (T const & a, packT ... pack)
 { return a*2 + decimal(pack...); }

int main(int argc, char *argv[])
 {
   constexpr  int  val { decimal(0, 0, 1) };

   static_assert( val == 2, "!");

   std::cout << val << std::endl;

   return 0;
 }

But I obtain 2, not 4.

Are you sure that your code should return 4?

-- EDIT --

As pointed by aschepler, my example decimal() template function return "eturns twice the sum of its arguments, which is not" what do you want.

Well, with 0, 1, true and false you obtain the same; with other number, you obtain different results.

But you can modify decimal() as follows

template <typename ... packT>
constexpr int decimal (bool a, packT ... pack)
 { return a*2 + decimal(pack...); }

to avoid this problem.

This returns twice the sum of its arguments, which is not what's wanted. — aschepler, Oct 14 '16 at 13:12
@aschepler - you're right; my intention was to make a more flexible function but should be explained. Modified my answer. — max66, Oct 14 '16 at 13:23

score 0 · Answer 3 · answered Oct 14 '16 at 13:27

This is a C++14 solution. It is mostly C++11, except for std::integral_sequence nad std::index_sequence, both of which are relatively easy to implement in C++11.

template<bool...bs>
using bools = std::integer_sequence<bool, bs...>;

template<std::uint64_t x>
using uint64 = std::integral_constant< std::uint64_t, x >;

template<std::size_t N>
constexpr uint64< ((std::uint64_t)1) << (std::uint64_t)N > bit{};

template<std::uint64_t... xs>
struct or_bits : uint64<0> {};

template<std::int64_t x0, std::int64_t... xs>
struct or_bits<x0, xs...> : uint64<x0 | or_bits<xs...>{} > {};

template<bool...bs, std::size_t...Is>
constexpr
uint64<
  or_bits<
    uint64<
      bs?bit<Is>:std::uint64_t(0)
    >{}...
  >{}
>
from_binary( bools<bs...> bits, std::index_sequence<Is...> ) {
  (void)bits; // suppress warning
  return {};
}


template<bool...bs>
constexpr
auto from_binary( bools<bs...> bits={} )
-> decltype( from_binary( bits, std::make_index_sequence<sizeof...(bs)>{} ) )
{ return {}; }

It generates the resulting value as a type with a constexpr conversion to scalar. This is slightly more powerful than a constexpr function in its "compile-time-ness".

It assumes that the first bit is the most significant bit in the list.

You can use from_binary<1,0,1>() or from_binary( bools<1,0,1>{} ).

Live example.

This particular style of type-based programming results in code that does all of its work in its signature. The bodies consist of return {};.

Variadic Template Recursion

3 Answers3