I have a std::variant
that I'd like to convert to another std::variant
that has a super-set of its types. Is there a way of doing it than that allows me to simply assign one to the other?
template <typename ToVariant, typename FromVariant>
ToVariant ConvertVariant(const FromVariant& from) {
ToVariant to = std::visit([](auto&& arg) -> ToVariant {return arg ; }, from);
return to;
}
int main()
{
std::variant<int , double> a;
a = 5;
std::variant <std::string, double, int> b;
b = ConvertVariant<decltype(b),decltype(a)>(a);
return 0;
}
I'd like to be able to simply write b = a
in order to do the conversion rather than going through this complex casting setup. Without polluting the std
namespace.
Edit: Simply writing b = a
gives the following error:
error C2679: binary '=': no operator found which takes a right-hand operand of type 'std::variant<int,double>' (or there is no acceptable conversion)
note: while trying to match the argument list '(std::variant<std::string,int,double>, std::variant<int,double>)'
This is an implementation of Yakk's second option:
template <class... Args>
struct variant_cast_proxy
{
std::variant<Args...> v;
template <class... ToArgs>
operator std::variant<ToArgs...>() const
{
return std::visit([](auto&& arg) -> std::variant<ToArgs...> { return arg ; },
v);
}
};
template <class... Args>
auto variant_cast(const std::variant<Args...>& v) -> variant_cast_proxy<Args...>
{
return {v};
}
You might want to fine tune it for forwarding semantics.
And as you can see its use is simple:
std::variant<int, char> v1 = 24;
std::variant<int, char, bool> v2;
v2 = variant_cast(v1);
Options:
Write your own variant
type, possibly inheriting from std::variant
, that implements operator=
and construction the way you want. Some work has to be done, because variant
's constructors can do SFINAE tricks that might not work properly with your variant type; to that end, you want to do some SFINAE forwarding to base-variant yourself instead of naked using
declarations.
Write a better ConvertVariant
that doesn't require the source/destination types to be listed. You would return a convert helper template type that holds the source variant which has an operator std::variant<Ts...>()&&
that calls something very much like your ConvertVariant
.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With