Void type in std::tuple

Question

Obviously, you can't have an instance of type void in a well-formed program, so something like the following declaration won't compile:

std::tuple<void, double, int> tup;

However, as long as we're dealing strictly with types as opposed to objects, there seems to be no issue. For example, my compiler (GCC) lets me say:

typedef std::tuple<void, double, int> tuple_type;

This is interesting to me, because it seems that with C++0x we can just use std::tuple to perform a lot of the meta-programming tricks that earlier would have required the boost::mpl library. For example, we can use std::tuple to create a vector of types.

For example, suppose we want to create a vector of types representing a function signature:

We can just say:

template <class R, class... Args>
struct get_function_signature;

template <class R, class... Args>
struct get_function_signature<R(*)(Args...)>
{
    typedef std::tuple<R, Args...> type;
};

This seems to work, even if the function signature has a void type, as long as we never actually instantiate an instance of get_function_signature<F>::type.

However, C++0x is still new to me, and of course all implementations are still somewhat experimental, so I'm a bit uneasy about this. Can we really use std::tuple as a vector of types for meta-programming?

Answer 1

It does actually make sense that you can do

typedef std::tuple<void, double, int > tuple_type;

as long as you only use it as a type-list to use tuple_element on. Thus I can do

tuple_element<0,tuple_type>::type * param;

which will declare param as void*