Convert std::variant to std::variant

Question

I have the following code:

std::variant<A, B> foo();
std::variant<A, B, C> bar();
std::variant<A, B, C> foobar(bool a) {
    if (a) {
        return foo();
    } else {
        return bar();
    }
}

However, this doesn't compile on gcc:

error: could not convert ‘foo()’ from ‘variant<A, B>’ to ‘variant<A,B,C>’.

Is there an elegant way to convert std::variant<A, B> into std::variant<A, B, C>?

[std::static_cast](https://en.cppreference.com/w/cpp/language/static_cast) — Ripi2, Nov 23 '19 at 18:08
@Ripi2: That doesn't work. `variant` is not convertible to a `variant` of other types. — Nicol Bolas, Nov 23 '19 at 18:08
You could replace the return type with `auto` and use `if constexpr`. — David G, Nov 23 '19 at 18:16
A `std::variant` is not a `std::variant `. Different types. Why would you think you could cast between them? Remember: a cast doesn't *convert* anything. It just reinterprets bits through different glasses. — Jesper Juhl, Nov 23 '19 at 18:18
Note that the appropriate term here is **convert** (as in the error message), not **cast**. A cast is something you write in your source code to tell the compiler to do a conversion. — Pete Becker, Nov 23 '19 at 18:21
Possible duplicate of [Convert std::variant to another std::variant with super-set of types](https://stackoverflow.com/questions/47203255/convert-stdvariant-to-another-stdvariant-with-super-set-of-types) and from that answer `variant_cast(foo())` works juuust fine — KamilCuk, Nov 23 '19 at 18:29

max66 · Answer 1 · 2019-11-23T18:42:22.560

Is there an elegant way to convert std::variant<A, B> into std::variant<A, B, C>?

No, I suppose.

The best I can imagine pass through std::visit(); something as

std::variant<A, B, C> foobar (bool a)
 {
   if (a) 
      return std::visit([](auto && val) -> std::variant<A, B, C>
                        { return {std::forward<decltype(val)>(val)}; },
                        foo());
   else
      return bar();
 }

A more general solution, could be a convVariant() function

template <typename R, typename T>
R convVariant (T && t)
 {
   return std::visit([](auto && val) -> R
                        { return {std::forward<decltype(val)>(val)}; },
                        std::forward<T>(t));
 }

so foobar() become

std::variant<A, B, C> foobar (bool a)
 {
   if (a) 
      return convVariant<std::variant<A, B, C>>(foo());
   else
      return bar();
 }

score 1 · Answer 2 · answered Nov 23 '19 at 18:31

In principle, the standard could allow implicit (if guaranteed successful) or explicit (otherwise) conversion from std::variant<T...> to std::variant<U...> if all types in the former occurred at least as often in the latter, as there is an unambiguous and obvious mapping.

Unfortunately, it simply doesn't.

Thus, you have to write your own function for converting.

Convert std::variant to std::variant

2 Answers2