如何根据元素数量终止可变参数模板递归？

Question

I've written a compile time search and find through template parameters, and it's working fine. I'm stumped about how to go about providing a default value for when there is no item found.

I've tried using sizeof...(args_t) to create a template specialization to terminate on. That isn't allowed. And so, I'm not sure how to go about doing this.

Here's what I've got right now:

template <typename... args_t> class c
{
    template <size_t pos, typename _t, typename... a_t> struct at : at<pos - 1, a_t...> { };
    template <typename _t, typename... a_t> struct at<0, _t, a_t...>
    {
        using t = _t;
    };
};

What I need is something like:

template <typename... args_t> class c
{
    template <> struct at<sizeof...(args_t)>
    {
        using t = default_value;
    };
};

So, how do I go about creating a template specialization based on the number of variadic elements?

Answer 1

You may use the following to manage case where index is outside bound:

template <typename... args_t> class c
{
    template <std::size_t pos, typename... Ts> struct at;

    template <std::size_t pos, typename T, typename... Ts>
    struct at<pos, T, Ts...> : at<pos - 1, Ts...>
    {};

    template <typename T, typename... Ts>
    struct at<0, T, Ts...>
    {
        using type = T;
    };

    template <std::size_t N>
    struct at<N>
    {
        using type = void; // default type
    };

};

Live example

Or using std::tuple and std::conditional (with lazy evaluation):

template <typename... args_t> class c
{
public:
    struct default_type { using type = void; };

    template <std::size_t pos, typename... Ts>
    struct at
    {
        using type =
            typename std::conditional<
                (pos < sizeof...(Ts)),
                std::tuple_element<pos, std::tuple<Ts...>>, // don't use ::type here
                default_type
            >::type::type; // expand type 'twice'.
    };

};

Live example

Answer 2

This might not be the best way, but here goes. The premise is to implement it with being told explicitly whether or not to use the default type, and then having the exposed interface provide that template argument based on the conditions you want.

struct Default {}; //our default type

//basic template to specialize
template<std::size_t Pos, bool UseDefault, typename... Ts>
struct At_;

//handle the default; UseDefault will be true if Pos is out of range
template<std::size_t Pos, typename... Ts>
struct At_<Pos, true, Ts...> {
    using type = Default;
};

//handle base case of reaching the element at Pos;
template<typename Head, typename... Tail>
struct At_<0, false, Head, Tail...> {
    using type = Head;
};

//handle all other cases
template<std::size_t Pos, typename Head, typename... Tail>
struct At_<Pos, false, Head, Tail...> : At_<Pos - 1, false, Tail...> {};

//use the default if Pos is out of range
template<std::size_t Pos, typename... Ts>
using At = typename At_<Pos, sizeof...(Ts) <= Pos, Ts...>::type;

You can see it work with a few tests here . This also seems to work for negative indices given a replacement for std::size_t that is signed. I would also recommend the At_ stuff go in a detail namespace of some sort.