CODEWITHSUNDEEP
c++g++c++11
pascal
pascal

Reputation: 2713

Why doesn't this template specialization work in GCC?

I want to create a tuple from the first n elements of another tuple. This is the recursion I use (doesn't calculate anything useful here).

Weirdly, it doesn't work using g++ 4.6.1, even though as I understand it, front<0,…> is more specialized than front<n,…> and it should be selected. Is this a bug or am I confused about specialization?

#include <tuple>

template<std::size_t, typename>
struct front;

#if 0
// This works, but I only want one case.
template<typename Head, typename... Tail>
struct front<0, std::tuple<Head, Tail...>> {
    typedef std::tuple<> type;
};
template<typename Head>
struct front<0, std::tuple<Head>> {
    typedef std::tuple<> type;
};
template<>
struct front<0, std::tuple<>> {
    typedef std::tuple<> type;
};
#elseif 0
// this doesn't work, but I don't understand why:
// ambiguous class template instantiation, candidates are:
//  struct front<0u, std::tuple<_Elements ...> >
//  struct front<n, std::tuple<_Head, _Tail ...> >
template<typename... Tail>
struct front<0, std::tuple<Tail...>> {
    typedef std::tuple<> type;
};
#else
// neither does this:
// ambiguous class template instantiation, candidates are:
//  struct front<0u, T>
//  struct front<n, std::tuple<_Head, _Tail ...> >
template<typename T>
struct front<0, T> {
    typedef std::tuple<> type;
};
#endif
// this makes no sense, but it's short.
template<std::size_t n, typename Head, typename... Tail>
struct front<n, std::tuple<Head, Tail...>> {
    typedef typename front<n - 1, std::tuple<Tail...>>::type type;
};
// check all cases, error includes calculated type:
front<0, std::tuple<int, float, double, long>>::type x0 = 0;
front<2, std::tuple<int, float, double, long>>::type x2 = 0;
front<4, std::tuple<int, float, double, long>>::type x4 = 0;

Upvotes: 0

Views: 262

Answers (1)

user743382
user743382

Reputation:

Template arguments aren't picked from left to right. Yes, 0 is more specialized than n, but std::tuple<Head, Tail...> is more specialized than T. You can add an extra specialization, which is the most specialized for both arguments:

#include <tuple>

template<typename A, typename B>
struct front_helper;

template<typename... A, typename... B>
struct front_helper<std::tuple<A...>, std::tuple<B...>> {
    typedef std::tuple<A..., B...> type;
};

template<std::size_t, typename>
struct front;

template<>
struct front<0, std::tuple<>> {
    typedef std::tuple<> type;
};
template<typename Head, typename... Tail>
struct front<0, std::tuple<Head, Tail...>> {
    typedef std::tuple<> type;
};
template<std::size_t n, typename Head, typename... Tail>
struct front<n, std::tuple<Head, Tail...>> {
    typedef typename front_helper<std::tuple<Head>, typename front<n-1, std::tuple<Tail...>>::type>::type type;
};

void x0(front<0, std::tuple<int, float, double, long>>::type) { }
void x1(front<1, std::tuple<int, float, double, long>>::type) { }
void x2(front<2, std::tuple<int, float, double, long>>::type) { }
void x3(front<3, std::tuple<int, float, double, long>>::type) { }
void x4(front<4, std::tuple<int, float, double, long>>::type) { }

$ g++ test.cc -c -std=c++0x && nm -C test.o
00000000 b .bss
00000000 d .data
00000000 t .text
00000000 T x0(std::tuple<>)
00000005 T x1(std::tuple<int>)
0000000a T x2(std::tuple<int, float>)
0000000f T x3(std::tuple<int, float, double>)
00000014 T x4(std::tuple<int, float, double, long>)
00000000 b std::(anonymous namespace)::ignore

Upvotes: 2

Related Questions