Question

For silly reasons I’ll not go into here, I need the commented out line to work and the line above it it to not work:

template<uint _N, typename... _Args>
struct PartialTuple;

template<uint _N, typename _Arg, typename... _Args>
struct PartialTuple<_N, _Arg, _Args...>: PartialTuple<_N-1, _Args...> {};

template<typename _Arg, typename... _Args>
struct PartialTuple<0, _Arg, _Args...>
{
    typedef std::tuple<_Arg, _Args...> type;
};

int main()
{
    // I want this to not work...
    PartialTuple<1, std::string, std::string, int, int>::type A{"test", 5, 1};

    // I want this to work...
    //PartialTuple<1, std::string, std::string, int, int>::type B{"test", "test", 5};
}

I tried swapping _Arg with _Args..., but that won’t compile (at least in GCC 4.6):

error: parameter pack argument ‘_Args ...’ must be at the end of the template argument list

How can I pull items off from the tail instead of from the head?

Answer 1

Here’s a solution: Instead of truncating N from the back, I just truncate sizeof...(Args) - N from the front:

#include <tuple>

/* Concatenator helper */

template <typename T, typename Tuple> struct cat;
template <typename T, typename ...Args>
struct cat<T, std::tuple<Args...>>
{
  typedef typename std::tuple<T, Args...> value;
};


/* Head-of-tuple */

template <unsigned int, typename...> struct tuple_head;

// Base case. Need to specialize twice, once for one and once for variadic types
template <typename ...Args>
struct tuple_head<0, Args...>
{
  typedef std::tuple<> value;
};
template <typename T>
struct tuple_head<0, T>
{
  typedef std::tuple<> value;
};

// Recursion step
template <unsigned int N, typename T, typename ...Args>
struct tuple_head<N, T, Args...>
{
  typedef typename cat<T, typename tuple_head<N - 1, Args...>::value>::value value;
};


/* User interface */

template <unsigned int N, typename ...Args>
struct PartialTuple
{
  typedef typename tuple_head<sizeof...(Args) - N, Args...>::value type;
};


/* Usage */

#include <string>
int main()
{
  // I want this to not work...
  //PartialTuple<1, std::string, std::string, int, int>::type A{"test", 5, 1};

  // I want this to work...
  PartialTuple<1, std::string, std::string, int, int>::type B("test", "test", 5);
  PartialTuple<0, std::string, std::string, int, int>::type C("test", "test", 5, 6);
}