Difference between revisions of "Std::variant"
From Chilipedia
Albinopapa (Talk | contribs) (Created page with " == What is <code>std::variant</code>? == In C++17, std::variant was introduced and is basically a strongly typed <code>union</code>. It allows you to specify a list of state...") |
Albinopapa (Talk | contribs) |
||
| Line 10: | Line 10: | ||
First, the safe way. There are a few versions that pretty much do the same thing. Since the compiler knows the type stored in an <code>std::variant</code>, you can use the <code>std::visit</code> function to have the compiler choose which function to handle the variant. | First, the safe way. There are a few versions that pretty much do the same thing. Since the compiler knows the type stored in an <code>std::variant</code>, you can use the <code>std::visit</code> function to have the compiler choose which function to handle the variant. | ||
| − | < | + | <source> |
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | #include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | ||
#include <iostream> // for std::cout | #include <iostream> // for std::cout | ||
| Line 42: | Line 42: | ||
return 0; | return 0; | ||
} | } | ||
| − | </ | + | </source> |
Version two using a function object as the 'visitor'. | Version two using a function object as the 'visitor'. | ||
| − | < | + | <source> |
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | #include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | ||
#include <iostream> // for std::cout | #include <iostream> // for std::cout | ||
| Line 79: | Line 79: | ||
return 0; | return 0; | ||
} | } | ||
| − | </ | + | </source> |
Version 3 using lambdas for the 'visitor' | Version 3 using lambdas for the 'visitor' | ||
| − | < | + | <source> |
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | #include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | ||
#include <iostream> // for std::cout | #include <iostream> // for std::cout | ||
| Line 117: | Line 117: | ||
return 0; | return 0; | ||
} | } | ||
| − | </ | + | </source> |
Do note that for each type in the variant, you must have a case handling the 'visit' or you'll get a compile time error, and it is nowhere near helpful in determining what case you missed, but not impossible. | Do note that for each type in the variant, you must have a case handling the 'visit' or you'll get a compile time error, and it is nowhere near helpful in determining what case you missed, but not impossible. | ||
Next is a safe way, but can be less efficient depending on your accuracy in knowing the type being stored. | Next is a safe way, but can be less efficient depending on your accuracy in knowing the type being stored. | ||
| − | < | + | <source> |
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | #include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | ||
#include <iostream> // for std::cout | #include <iostream> // for std::cout | ||
| Line 156: | Line 156: | ||
return 0; | return 0; | ||
} | } | ||
| − | </ | + | </source> |
Unlike <code>std::tuple</code>, variants cannot hold multiples of the same type. Each type in the template parameter list must be unique. | Unlike <code>std::tuple</code>, variants cannot hold multiples of the same type. Each type in the template parameter list must be unique. | ||
Finally, the unsafe way. | Finally, the unsafe way. | ||
| − | < | + | <source> |
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | #include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant | ||
#include <iostream> // for std::cout | #include <iostream> // for std::cout | ||
| Line 185: | Line 185: | ||
return 0; | return 0; | ||
} | } | ||
| − | </ | + | </source> |
This example, made it safe by using the retrieved type directly after assignment, but after that, the user may not know what state the variant is in and calling <code>std::get</code> on the wrong type will throw a <code>std::bad_variant_access</code> exception. The above method of assigning the value, then retrieving a reference to the underlying type allows you to modify the state of the object from within without having to setup visitors just for initialization. | This example, made it safe by using the retrieved type directly after assignment, but after that, the user may not know what state the variant is in and calling <code>std::get</code> on the wrong type will throw a <code>std::bad_variant_access</code> exception. The above method of assigning the value, then retrieving a reference to the underlying type allows you to modify the state of the object from within without having to setup visitors just for initialization. | ||
== Requirements for <code>std::variant</code> == | == Requirements for <code>std::variant</code> == | ||
| + | * The list of types must be unique, a variant cannot be declared with two ints and a float | ||
| + | * The types in a variant must be default constructable or the use of <code>std::monostate</code> can be set as the first type in the parameter list | ||
| + | <source> | ||
| + | std::variant<std::monostate, MyComplexClass, MyComplexClass1> data; | ||
| + | </source> | ||
| + | * Types in <code>std::variant</code> parameter list, must not be forward declared types. The compiler must be able to determine whether or not the types in the list are default constructable before instantiating a variant of those types. | ||
| + | * The list may not contain reference types: int&, const MyCompolexClass& | ||
Latest revision as of 04:28, 18 October 2018
What is std::variant?
In C++17, std::variant was introduced and is basically a strongly typed union. It allows you to specify a list of states that the std::variant can be in. These states are actually types, such as int, float, double, MyClass. It can only be in one state at a time, so if you assign it an int on one line, then assign it a float on another, the int is no long able to be retrieved.
How to use std::variant
Std::variant has kind of a black-box approach in dealing with access to the data stored. While this does allow for some optimizations to be made in the form of compile time knowledge for the compiler, it makes it non-trivial for the user to access. Luckily, there are options, from safe but requires a bit of boiler-plate to not so safe but trivial. Look at the examples below.
First, the safe way. There are a few versions that pretty much do the same thing. Since the compiler knows the type stored in an std::variant, you can use the std::visit function to have the compiler choose which function to handle the variant.
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout
void PrintNumber( const int _number )
{
std::cout << _number << '\n';
}
void PrintNumber( const float _number )
{
std::cout << _number << '\n';
}
void PrintNumber( const double _number )
{
std::cout << _number << '\n';
}
int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;
number = 42; // number is now considered an int
std::visit( &PrintNumber, number ); // The PrintNumber( int ) overload should be called
number = 3.14159f; // number is now considered a float
std::visit( &PrintNumber, number ); // The PrintNumber( float ) overload should be called
number = 2.5 // number is now considered a double
std::visit( &PrintNumber, number ); // The PrintNumber( double ) overload should be called
return 0;
}Version two using a function object as the 'visitor'.
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout
struct PrintNumber
{
void operator()( const int _number )
{
std::cout << _number << '\n';
}
void operator()( const float _number )
{
std::cout << _number << '\n';
}
void operator()( const double _number )
{
std::cout << _number << '\n';
}
};
int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;
number = 42; // number is now considered an int
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( int ) overload should be called
number = 3.14159f; // number is now considered a float
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( float ) overload should be called
number = 2.5 // number is now considered a double
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( double ) overload should be called
return 0;
}Version 3 using lambdas for the 'visitor'
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout
int main( int ArgsC, char* ArgV[] )
{
auto PrintNumber = []( auto _number )
{
using type = std::decay_t<decltype( _number )>;
if constexpr( std::is_same_v<type, int> )
{
std::cout << _number << '\n';
}
else if constexpr( std::is_same_v<type, float> )
{
std::cout << _number << '\n';
}
else if constexpr( std::is_same_v<type, double> )
{
std::cout << _number << '\n';
}
};
std::variant<int, float, double> number;
number = 42; // number is now considered an int
std::visit( PrintNumber, number ); // The if constexpr( std::is_same_v<type, int> ) branch should be used
number = 3.14159f; // number is now considered a float
std::visit( PrintNumber, number ); // The else if constexpr( std::is_same_v<type, float> ) branch should be used
number = 2.5 // number is now considered a double
std::visit( PrintNumber, number ); // The else if constexpr( std::is_same_v<type, double> ) branch should be used
return 0;
}Do note that for each type in the variant, you must have a case handling the 'visit' or you'll get a compile time error, and it is nowhere near helpful in determining what case you missed, but not impossible.
Next is a safe way, but can be less efficient depending on your accuracy in knowing the type being stored.
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout
void PrintNumber( std::variant<int, float, double>& _number )
{
if( const int* myInt = std::get_if<int>( &_number ); myInt != nullptr )
{
std::cout << *myInt << '\n';
}
else if( const float* myFloat = std::get_if<float>( &_number ); myFloat != nullptr )
{
std::cout << *myFloat << '\n';
}
else if( const double* myDouble = std::get_if<double>( &_number ); myDouble != nullptr )
{
std::cout << *myDouble << '\n';
}
}
int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;
number = 42; // number is now considered an int
PrintNumber( number );
number = 3.14159f; // number is now considered a float
PrintNumber( number );
number = 2.5 // number is now considered a double
PrintNumber( number );
return 0;
}Unlike std::tuple, variants cannot hold multiples of the same type. Each type in the template parameter list must be unique.
Finally, the unsafe way.
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout
int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;
number = 42; // number is now considered an int
int& myInt = std::get<int>( number );
myInt = 69;
std::cout << myInt << '\n';
number = 3.14159f; // number is now considered a float
float& myFloat = std::get<float>( number );
myFloat = 0.707f
std::cout << myFloat << '\n';
number = 2.5 // number is now considered a double
double& myDouble = std::get<double>( number );
myDouble = 419.999999999
std::cout << myDouble << '\n';
return 0;
}This example, made it safe by using the retrieved type directly after assignment, but after that, the user may not know what state the variant is in and calling std::get on the wrong type will throw a std::bad_variant_access exception. The above method of assigning the value, then retrieving a reference to the underlying type allows you to modify the state of the object from within without having to setup visitors just for initialization.
Requirements for std::variant
- The list of types must be unique, a variant cannot be declared with two ints and a float
- The types in a variant must be default constructable or the use of
std::monostatecan be set as the first type in the parameter list
std::variant<std::monostate, MyComplexClass, MyComplexClass1> data;- Types in
std::variantparameter list, must not be forward declared types. The compiler must be able to determine whether or not the types in the list are default constructable before instantiating a variant of those types. - The list may not contain reference types: int&, const MyCompolexClass&
