带有空参数包的递归可变参数模板（以避免重复基本情况）

Question

I am experimenting with C++ recursive templates and I do not know why my template is not working.

Say I want to define a recursive function that takes a variable number of arguments (for different types).

I've have looked at many examples of variadic templates, and all that I've seen so far use a separate template specialisation to specify the base case.

However, I think it would be nicer (in some cases at least) to use a single template, that defines the base case as well as the recursive cases.

I think this approach is especially nice if you have a lot of common logic in the function, which you would have to duplicate for your base case instance (exact same code in two different places).

The second template in the example below is supposed to be my solution. I would think that this template should be functioning on it's own. However this is not the case.

Without the first template, the code does not compile:

error: no matching function for call to
      'add_elems'
        return head[i] + add_elems(i, second, tail...);
                         ^~~~~~~~~
in instantiation of function
      template specialization 'add_elems<double, std::__1::vector<double, std::__1::allocator<double> >>' requested here

...

Apparently the template braks when tail consists of just one parameter. But shouldn't add_elems(i, second, tail...) then still be valid for the template template<typename V, typename S, typename... T> V add_elems(size_t i, const std::vector<V>& head, const S& second, const T&... tail) with an empty tail ?

I do not know if this is compiler dependent, but I am using clang.

#include <iostream>
#include <vector>

/* This template is the exact same as the below template with an
      empty parameter pack as tail. I want my code to be working 
      without this specialisation */
template<typename V, typename S>
V add_elems(size_t i, const std::vector<V>& head, const S& second)
{
    /* Imagine some more code here */
    return head[i] + second[i];
}

template<typename V, typename S, typename... T>
V add_elems(size_t i, const std::vector<V>& head, const S& second, const T&... tail)
{
    /* Imagine some more code here (the same as above) */

    if (sizeof...(tail) > 0)
        return head[i] + add_elems(i, second, tail...);
    else
        return head[i] + second[i];
}

int main()
{
    std::vector<double> a({1, -3, -3});
    std::vector<double> b({2, -2, 1});
    std::vector<double> c({4, -4, -11});
    std::vector<double> d({4, 10, 0});

    std::cout << "Result: " << add_elems(0, a, b, c, d);
    std::cout << " ," << add_elems(1, a, b, c, d);
    std::cout << " ," << add_elems(2, a, b, c, d);
}

Answer 1

The problem is that your if statement is not constexpr . Meaning that all code paths need to be compilable for every potential call to add_elems

This means that eventually you end up at a case where tail is just one element, and the compiler needs to evaluate add_elems(size_t&, const, std::vector<double>&) , which doesn't exist because there's no second argument.

If you were able to have a constexpr if statement, then this would all work nicely because the compiler wouldn't even compile the bad branch when it evaluates to false, and therefore wouldn't look for a nonexistent function:

template<typename V, typename S, typename... T>
V add_elems(size_t i, const std::vector<V>& head, const S& second, const T&... tail)
{
    if constexpr (sizeof...(tail) > 0)
        return head[i] + add_elems(i, second, tail...);
    else
        return head[i] + second[i];
}

Demo (requires Clang 3.9.1 or greater and -std=c++1z option.)

For what it's worth, if you have access to C++17, you can achieve this with a unary right fold :

template<typename... T>
decltype(auto) add_elems(size_t i, const T&... elems)
{
    return (elems[i] + ...);
}

Demo 2 (requires Clang 3.6.0 or greater and -std=c++1z option.)

Answer 2

Waiting for C++17, I propose a C++11 not-so-nice solution, following the AndyG one

template <typename T0, typename ... T>
auto add_elems2 (size_t i, T0 const & elem0, T const & ... elems)
   -> decltype(elem0[i])
 {
   using unused=int[];

   auto ret = elem0[i];

   unused a { (ret += elems[i], 0)... };

   return ret;
 }

Answer 3

As the error message says, the problem you have at the moment is that the call add_elems(i, second, tail...) doesn't match the definition of the function, in the case where tail is empty. Even though the boolean expression in the if statement is constexpr, until c++1z the whole body of the function has to be valid.

@AndyG provides one way that c++1z can deal with this issue, another is with if constexpr , which allows a "compile time branch". Either of those allow you to have one (primary) specialisation of your template.

// Only in c++1z
template<typename V, typename S, typename... T>
V add_elems(size_t i, const std::vector<V>& head, const S& second, const T&... tail)
{
    /* Imagine some more code here (the same as above) */

    if constexpr (sizeof...(tail) > 0)
        return head[i] + add_elems(i, second, tail...); // this is not required to be valid when the if is false
    else
        return head[i] + second[i]; // this is not required to be valid when the if is true (but it is happens to be valid anyway)
}

Answer 4

As many have noted, this is easy in C++1z. It can be done in C++14, it is just hard.

template<class True, class False>
True pick( std::true_type, True t, False ) {
  return std::move(t);
}
template<class True, class False>
False pick( std::false_type, True, False f ) {
  return std::move(f);
}
template<bool b>
constexpr std::integral_constant<bool, b> bool_k;


template<typename V, typename S, typename... T>
V add_elems(size_t i, const std::vector<V>& head, const S& second, const T&... tail)
{
  return
    pick( bool_k<(sizeof...(tail)>0)>,
      [&](const auto&... tail)->V{
        // tail... template argument hides function argument above:
        return head[i] + add_elems(i, second, tail...);
      },
      [&]()->V{
        return head[i] + second[i];
      }
    )
    ( tail... );
};

we do a compile time dispatch using pick to one of two lambdas.

These lambdas take the part of the code that varies by auto parameter, which makes them templates. So long as they are valid for some set of auto parameters (even ones they are "never called with"), they are legal C++.

What we have readly done is hide the two overloads within the lambdas. As C++11 doesn't have template lambdas, this "hidden overload" technique won't work in C++11.

Answer 5

You can use Boost.Hana to emulate the behaviour of if constexpr in C++14. For example:

template <typename...>
struct is_empty_pack : hana::integral_constant<bool, false> {};
template <>
struct is_empty_pack<> : hana::integral_constant<bool, true> {};

template <typename T, typename... Ts>
auto sum(T const& t, Ts const&... ts) {
  return hana::if_(is_empty_pack<Ts...>{},
    [](auto const& t) { return t; },
    [](auto const& t, auto const&... ts) { return t + sum(ts...); }
  )(t, ts...);
}