Question

A hypothetical variadic template tuple class would, as far as I can tell, have to use getters with template parameters.

int MyInt = MyTuple.Get<int>(0);

This is inconvenient, and introduces potential for error. I can’t help but feel that there’s a way to construct the class so you you don’t have to explicitly specify it.

int MyInt = MyTuple.Get(0);

My first thought was for the Get() member function to return another class that figures out the type on its own, probably by comparing typeid(Foo).name() to values in some precomputed list. That still has to happen before runtime, though, and I couldn’t figure out a way to iterate through anything like that at compile-time.

Is there any way for a variadic template container class – like a tuple – to have a getter that doesn’t require the type to be explicitly specified?

Answer 1

You mean like std::tuple?

The getter’s template argument specifies the index of the member, not the type. By definition, the number and types of a tuple are fixed at compile time. Since the type depends on the index, and the type must be known at compile time, the getter must be templated.

template< typename ... types >
struct tuple;

template< typename head, typename ... tail_types >
struct tuple {
    head value;
    tuple< tail_types ... > tail;
};

template<>
struct tuple<> {};

template< typename tuple, size_t index >
struct tuple_element;

template< typename head, typename ... tail, size_t index >
struct tuple_element< tuple< head, tail ... >, index >
    { typedef typename tuple_element< tail ..., index - 1 >::type type; };

template< typename head, typename ... tail >
struct tuple_element< tuple< head, tail ... >, 0 >
    { typedef head type; };

template< size_t index, typename tuple >
typename std::enable_if< index != 0, 
                   typename tuple_element< tuple, index >::type >::type
get( tuple const &t )
    { return get< index - 1 >( t.tail ); }

template< size_t index, typename tuple >
typename std::enable_if< index == 0,
                   typename tuple_element< tuple, index >::type >::type
get( tuple const &t )
    { return t.value; }

etc.