/* Just playing around with variants and visitors which is the C++ equivalent of a C union but type safe. Like a C union, a variant can only have 1 active value at a time. For example, an std::variant can hold either an int, or a float, but not both. When none of the types are explicitly initialized then the first type is default initialized which could be a problem if you don't want that or if the first type is not default constructible. In these cases you can use the type std::monostate, the variant earlier would then become std::variant Unlike C, variants can be quite hard to work with when you don't know what you're doing. The way to 'easily' work with 1 or multiple variants is to use std::visit. The first parameter would be a callable object, like a lambda or a struct with a ( or multiple ) operator(), the other parameters N variants. The visitor pattern then calls the correct operator() based on the held types. To start off with, this program demonstrates how to print what is held in the variant, how to do operations on multiple variants and return a new one. https://en.cppreference.com/w/cpp/utility/variant https://en.cppreference.com/w/cpp/utility/variant/visit https://sourcemaking.com/design_patterns/visitor/cpp/1 https://en.cppreference.com/w/cpp/language/class_template_argument_deduction */ #include #include // Used so we can put multiple lambdas within 1 std::visit, which normally only allows 1 lambda // ( Hopefully std::overload gets added to the standard soon ) template struct overload : Ts... { // Brings all operator()'s into scope using Ts::operator()...; }; // User defined deduction guide template overload( Ts... ) -> overload; // Basically tells the compiler which template type to use for overload for a given parameter // Since lambdas have no type you can't do something like overload{ [](){}, [](){} } and have it compile. // That is where this deduction guide comes in, now it allows us to simply type: overload{ [](){}, [](){} } using variant_t = std::variant; int main() { { // We need the f the tell the compiler it's a float // otherwise the literal is a double and since std::variant does not allow implicit conversion, this would fail to compile variant_t var1 = 5.3f; // Create some lambdas that prints the held type and the value std::visit( overload{ // []( std::monostate ){ std::cout << "No value is held"; }, // If std::monostate was an option []( int v ){ std::cout << "Held item is an int with the value " << v; }, []( float v ){ std::cout << "Held item is a float with the value " << v; }, }, var1 ); } std::cout << "\n\n\n"; { // Create some lambdas that we can use later auto printVariant = overload{ []( int v ){ std::cout << v; }, []( float v ){ std::cout << v; }, }; auto variantType = overload{ []( int ){ std::cout << "Held item is an int"; }, []( float ){ std::cout << "Held item is a float"; }, }; variant_t var1 = 30; variant_t var2 = 51.5f; std::cout << "Adding values\nVar1: "; std::visit( variantType, var1 ); std::cout << ' '; std::visit( printVariant, var1 ); std::cout << "\nand\nVar2: "; std::visit( variantType, var2 ); std::cout << ' '; std::visit( printVariant, var2 ); std::cout << '\n'; // Need 1 lambda for every combination. 2 variants with 2 possible values each = 4 combinations // Don't forget to specify the return type with -> because variants do not do any implicit conversions // Go ahead, remove the "-> variant_t", I dare you ;) variant_t result = std::visit( overload{ []( int lhs, int rhs ) -> variant_t { return lhs + rhs; }, []( int lhs, float rhs ) -> variant_t { return lhs + rhs; }, []( float lhs, int rhs ) -> variant_t { return lhs + rhs; }, []( float lhs, float rhs ) -> variant_t { return lhs + rhs; }, }, var1, var2 ); std::cout << "\nResult is\n"; std::visit( variantType, result ); std::cout << ' '; std::visit( printVariant, result ); } return 0; }

C++17 Variants