Question

I am wondering, if it’s possible in C++0x to create a statically typed variant, (that behaves like auto) :

variant<int, bool, std::string> v = 45;

When we assign v to a value other than int, it doesn’t compile:

v = true; //Compile error

So far I haven’t found any elegant solution.

Answer 1

This code compiles on my machine with Boost.Variant and g++ 4.5 for both C++98 and C++0x. Do you want to implement a variant-type yourself? Then you might look into the Boost implementation.

In the case that you want to /get/ the above behaviour you could do it like this:

auto v = 45;
static_assert(std::is_same<decltype(v), bool>
              || std::is_same<decltype(v), int>
              || std::is_same<decltype(v), std::string>,
              "v must be int, bool or string");

This should be quite equivalent to what you describe.

The following implements Clintons suggestion:

template <typename T, typename... Args>
struct has_type;

template <typename T, typename Head, typename... Args>
struct has_type<T, Head, Args...>
{
    static const bool value = std::is_same<T, Head>::value
                              || has_type<T, Args...>::value;
};

template <typename T>
struct has_type<T> : std::false_type
{};

template <typename... Args, typename T>
T&& check_type (T&& t)
{
    static_assert(has_type<T, Args...>::value, "check_type");
    return std::move(t);
}

You only need <memory> and <type_traits> for this and get perfect forwarding and correct behaviour for integer promotion.