{"id":6226,"date":"2021-09-23T06:58:50","date_gmt":"2021-09-23T06:58:50","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/visiting-a-std-variant-with-the-overload-pattern\/"},"modified":"2021-09-23T06:58:50","modified_gmt":"2021-09-23T06:58:50","slug":"visiting-a-std-variant-with-the-overload-pattern","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/visiting-a-std-variant-with-the-overload-pattern\/","title":{"rendered":"Visiting a std::variant with the Overload Pattern"},"content":{"rendered":"

Typically, you use the overload pattern for a std::variant<\/code>. std::variant<\/code> is a type-safe union. A <\/code>std::variant<\/code> (C++17) has one value from one of its types. std::visit<\/code> allows you to apply a visitor to it. Exactly here comes the overload pattern convenient into play.<\/p>\n

<\/p>\n

 \"templates\"<\/p>\n

In my last post, “Smart Tricks with Parameter Packs and Fold Expressions<\/a>“, I introduced the overload pattern as a smart trick to create an overload set using lambdas. Typically, the overload pattern is used for visiting the value held by a std::variant<\/code>.<\/p>\n

I know from my C++ seminars that most developers don’t know std::variant<\/code> and std::visit<\/code> and still, use a union. Therefore, let me give you a quick reminder about std::variant<\/code> and std::visit<\/code>.<\/p>\n

std::variant (C++17)
<\/code><\/h2>\n

A std::variant<\/span> is a type-safe union. An instance of std::variant<\/span> has a value from one of its types. The value must not be a reference, C-array, or void.<\/span> A std::variant can have one type more than once. A default-initialized std::variant<\/span> will be initialized with its first type. In this case, the first type must have a default constructor. Here is an example based on cppreference.com.<\/a> <\/p>\n

<\/p>\n

\n
\/\/ variant.cpp<\/span>\r\n\r\n#include <variant><\/span>\r\n#include <string><\/span>\r\n \r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>variant<<\/span>int<\/span>, float<\/span>><\/span> v, w;\r\n  v =<\/span> 12<\/span>;                              \/\/ (1)<\/span>\r\n  int<\/span> i =<\/span> std::<\/span>get<<\/span>int<\/span>><\/span>(v);\r\n  w =<\/span> std::<\/span>get<<\/span>int<\/span>><\/span>(v);                \/\/ (2)<\/span><\/em>\r\n  w =<\/span> std::<\/span>get<<\/span>0<\/span>><\/span>(v);                  \/\/ (3)<\/span>\r\n  w =<\/span> v;                               \/\/ (4)<\/span>\r\n \r\n  \/\/  std::get<double>(v);             \/\/ (5) ERROR<\/span>\r\n  \/\/  std::get<3>(v);                  \/\/ (6) ERROR<\/span>\r\n \r\n  try{\r\n    std::<\/span>get<<\/span>float<\/span>><\/span>(w);                \/\/ (7)<\/span>\r\n  }\r\n  catch<\/span> (std::<\/span>bad_variant_access&<\/span>) {}\r\n \r\n  std::<\/span>variant<<\/span>std::<\/span>string><\/span> v(\"abc\"<\/span>);  \/\/ (8)<\/span>\r\n  v =<\/span> \"def\"<\/span>;                           \/\/ (9)<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I define both variants v<\/span> and w<\/span>. They can have an int<\/span> and a float<\/span> value. Their initial value is 0. v<\/span> becomes 12 (line 1). std::get<int>(v)<\/span> returns the value. In lines (2) – (3), you see three possibilities to assign variant v<\/span> the variant w.<\/span> But you have to keep a few rules in mind. You can ask for the value of a variant by type (line 5) or index (line 6). The type must be unique and the index valid. On line 7, the variant w<\/span> holds an int<\/span> value. Therefore, I get a std::bad_variant_access<\/span> exception. If the constructor or assignment call is unambiguous, a simple conversion occurs. That is the reason that it’s possible to construct a std::variant<std::string><\/span> in line (8) with a C-string or assign a new C-string to the variant (line 9).<\/p>\n
Thanks to the function std::visit<\/code>, C++17 provides a convenient way to visit the elements of a std::variant<\/code>.<\/p>\n<\/p>\n
std::visit<\/code><\/h2>\n
According to the classical design patterns, what sounds like the visitor pattern is a kind of visitor for a container of variants.<\/p>\n
std::visit<\/span> allows you to apply a visitor to a container of variants. The visitor must be callable. A callable is something that you can invoke. Typical callables are functions, function objects, or lambdas. I use lambdas in my example.<\/p>\n
<\/p>\n
\n
\/\/ visitVariants.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n#include <typeinfo><\/span>\r\n#include <variant><\/span>\r\n\r\n  \r\nint<\/span> main<\/span>(){\r\n  \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n    std::<\/span>vector<<\/span>std::<\/span>variant<<\/span>char<\/span>, long<\/span>, float<\/span>, int<\/span>, double<\/span>, long<\/span> long<\/span>>><\/span>      \/\/ 1<\/span>\r\n               vecVariant =<\/span> {5<\/span>, '2'<\/span>, 5.4<\/span>, 100ll<\/span>, 2011l<\/span>, 3.5f<\/span>, 2017<\/span>};\r\n  \r\n    for<\/span> (auto<\/span>&<\/span> v:<\/span> vecVariant){\r\n        std::<\/span>visit([](auto<\/span> arg){std::<\/span>cout <<<\/span> arg <<<\/span> \" \"<\/span>;}, v);                \/\/ 2<\/span>\r\n    }\r\n  \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n    for<\/span> (auto<\/span>&<\/span> v:<\/span> vecVariant){\r\n        std::<\/span>visit([](auto<\/span> arg){std::<\/span>cout <<<\/span> typeid<\/span>(arg).name() <<<\/span> \" \"<\/span>;}, v); \/\/ 3<\/span>\r\n    }\r\n  \r\n    std::<\/span>cout <<<\/span> \"\\n\\n\"<\/span>;\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I create in (1) a std::vector<\/span> of variants and initialize each variant. Each variant can hold a char, long, float, int, double,<\/span> or long long value. <\/span>It’s pretty easy to traverse the vector of variants and apply the lambda (lines (2) and (3) to it. First, I display the current value (2), and second, thanks to the call typeid(arg).name()<\/span> (3), I get a string representation of the type of the current value.<\/span><\/p>\n
\"visitVariants\"<\/p>\n
Fine? No!. I used it in the program visitVariant.cpp<\/code> generic lambda. Consequently, the string representations of the types are pretty unreadable using GCC: “i c d x l f i<\/code>“. Honestly, I want to apply a specific lambda to each type of the variant. Now, the overload pattern comes to my rescue.<\/p>\n
Overload Pattern<\/h3>\n
Thanks to the overload pattern, I can display each type with a readable string and display each value in an appropriate way.<\/p>\n
<\/p>\n
\n
\/\/ visitVariantsOverloadPattern.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n#include <typeinfo><\/span>\r\n#include <variant><\/span>\r\n#include <string><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> ... Ts><\/span>                                                 \/\/ (7)<\/span> <\/em>\r\nstruct<\/span> Overload :<\/span> Ts ... { \r\n    using<\/span> Ts::<\/span>operator<\/span>() ...;\r\n};\r\ntemplate<\/span><<\/span>class... Ts><\/span> Overload(Ts...) -><\/span> Overload<<\/span>Ts...><\/span>;\r\n\r\nint<\/span> main<\/span>(){\r\n  \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n    std::<\/span>vector<<\/span>std::<\/span>variant<<\/span>char<\/span>, long<\/span>, float<\/span>, int<\/span>, double<\/span>, long<\/span> long<\/span>>><\/span>  \/\/ (1)    <\/span>\r\n               vecVariant =<\/span> {5<\/span>, '2'<\/span>, 5.4<\/span>, 100ll<\/span>, 2011l<\/span>, 3.5f<\/span>, 2017<\/span>};\r\n\r\n    auto<\/span> TypeOfIntegral =<\/span> Overload {                                      \/\/ (2)<\/span>\r\n        [](char<\/span>) { return<\/span> \"char\"<\/span>; },\r\n        [](int<\/span>) { return<\/span> \"int\"<\/span>; },\r\n        [](unsigned<\/span> int<\/span>) { return<\/span> \"unsigned int\"<\/span>; },\r\n        [](long<\/span> int<\/span>) { return<\/span> \"long int\"<\/span>; },\r\n        [](long<\/span> long<\/span> int<\/span>) { return<\/span> \"long long int\"<\/span>; },\r\n        [](auto<\/span>) { return<\/span> \"unknown type\"<\/span>; },\r\n    };\r\n  \r\n    for<\/span> (auto<\/span> v :<\/span> vecVariant) {                                           \/\/ (3)<\/span>\r\n        std::<\/span>cout <<<\/span> std::<\/span>visit(TypeOfIntegral, v) <<<\/span> '\\n'<\/span>;\r\n    }\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>vector<<\/span>std::<\/span>variant<<\/span>std::<\/span>vector<<\/span>int<\/span>><\/span>, double<\/span>, std::<\/span>string>><\/span>      \/\/ (4)<\/span>\r\n        vecVariant2 =<\/span> { 1.5<\/span>, std::<\/span>vector<<\/span>int<\/span>><\/span>{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>}, \"Hello \"<\/span>};\r\n\r\n    auto<\/span> DisplayMe =<\/span> Overload {                                           \/\/ (5)<\/span>\r\n        [](std::<\/span>vector<<\/span>int<\/span>>&<\/span> myVec) { \r\n                for<\/span> (auto<\/span> v:<\/span> myVec) std::<\/span>cout <<<\/span> v <<<\/span> \" \"<\/span>;\r\n                std::<\/span>cout <<<\/span> '\\n'<\/span>; \r\n            },\r\n        [](auto<\/span>&<\/span> arg) { std::<\/span>cout <<<\/span> arg <<<\/span> '\\n'<\/span>;},\r\n    };\r\n\r\n    for<\/span> (auto<\/span> v :<\/span> vecVariant2) {                                         \/\/ (6)<\/span>\r\n        std::<\/span>visit(DisplayMe, v);\r\n    }\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Line (1) creates a vector of variants having integral types, and line (4) creates a vector of variants having a std::vector<int><\/code>, double<\/code>, and a std::string<\/code>.<\/p>\n
Let me continue with the first variant vecVariant<\/code>. TypeOfIntegral (2) is an overload set that returns for a few integral types a string representation. If the type is not handled by the overload set, I return the string “unknown type<\/code>“. In line (3), I apply the overload set to each variant v<\/code> using std::visit<\/code>.<\/p>\n
The second variant vecVariant2 (4), has composed types. I create an overload set (5) to display their values. In general, I can just push the value onto std:.cout<\/code>. For the std::vector<int><\/code>, I use a range-based for-loop to push its values to std::cout<\/code>.<\/p>\n
Finally, here is the output of the program.<\/p>\n
\"visitVariantsOverloadPattern\"<\/p>\n
<\/p>\n
\n
template<\/span><<\/span>typename<\/span> ... Ts><\/span>                                  \/\/ (1)<\/span>\r\nstruct<\/span> Overload :<\/span> Ts ... { \r\n    using<\/span> Ts::<\/span>operator<\/span>() ...;\r\n};\r\ntemplate<\/span><<\/span>class... Ts><\/span> Overload(Ts...) -><\/span> Overload<<\/span>Ts...><\/span>; \/\/ (2)<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Line (1) is the overload pattern, and line (2) is the deduction guide. The struct Overload<\/code> can have arbitrarily many base classes (Ts ...<\/code>). It derives from each class public<\/code> and brings the call operator (Ts::operator..<\/code>.) of each base class into its scope. The base classes need an overloaded call operator (Ts::operator()). Lambdas provide this call operator. The following example is as simple as it can be.<\/p>\n
<\/p>\n
\n
#include <variant><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> ... Ts><\/span>                                                 \r\nstruct<\/span> Overload :<\/span> Ts ... { \r\n    using<\/span> Ts::<\/span>operator<\/span>() ...;\r\n};\r\ntemplate<\/span><<\/span>class... Ts><\/span> Overload(Ts...) -><\/span> Overload<<\/span>Ts...><\/span>;\r\n\r\nint<\/span> main<\/span>(){\r\n  \r\n    std::<\/span>variant<<\/span>char<\/span>, int<\/span>, float<\/span>><\/span> var =<\/span> 2017<\/span>;\r\n\r\n    auto<\/span> TypeOfIntegral =<\/span> Overload {     \/\/ (1) <\/span><\/em>                                 \r\n        [](char<\/span>) { return<\/span> \"char\"<\/span>; },\r\n        [](int<\/span>) { return<\/span> \"int\"<\/span>; },\r\n        [](auto<\/span>) { return<\/span> \"unknown type\"<\/span>; },\r\n    };\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\"OverloadPatternInstantiated\"<\/p>\n
Second, the used lambdas in the overload pattern such as [](char) { return \"char\"; }<\/code> cause the creation of a function object. In this case, the compiler gives the function object the name __lambda_15_9<\/code>.<\/p>\n
\"lambdaChar\"<\/p>\n
Studying the auto-generate types show at least one interesting point. The call operator of __lambda_15_9 is overloaded for char: const char * operator() (char) const { return \"char\"; }<\/code><\/p>\n
The deduction guide (template<class... Ts> Overload(Ts...) -> Overload<Ts...>;<\/code>) (line 2) is only needed for C++17. The deduction guide tells the compiler how to create out-of-constructor arguments template parameters. C++20 can automatically deduce the template. <\/p>\n
What’s next?<\/h2>\n
The friendship of templates is special. In my next post, I will explain why.<\/p>\n
 <\/p>\n<\/p>\n
\n
\n
 <\/div>\n
\n
\n
 <\/div>\n
\n
 <\/p>\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Typically, you use the overload pattern for a std::variant. std::variant is a type-safe union. A std::variant (C++17) has one value from one of its types. std::visit allows you to apply a visitor to it. Exactly here comes the overload pattern convenient into play.<\/p>\n","protected":false},"author":21,"featured_media":6208,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[],"class_list":["post-6226","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6226","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=6226"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6226\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6208"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6226"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6226"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6226"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Using this example in C++ Insights<\/a> makes the magic transparent. First, call (1) causes the creation of a fully specialized class template.<\/p>\n
I want to add a few words to the overload pattern used in this example (7). I already introduced in my last post, “Smart Tricks with Parameter Packs and Fold Expressions<\/a>`.<\/p>\n
Of course, there is way more about std::variant.<\/code> Read the post “Everything You Need to Know About std::variant from C++17<\/a>” by Bartlomiej Filipek.<\/p>\n