#include <iomanip>#include <iostream>#include <string>#include <type_traits>#include <variant>#include <vector> // the variant to visitusing value_t=std::variant<int,long,double,std::string>; // helper type for the visitor #4template<class...Ts>struct overloaded: Ts...{using Ts::operator()...;};// explicit deduction guide (not needed as of C++20)template<class...Ts>overloaded(Ts...)-> overloaded<Ts...>; int main(){std::vector<value_t> vec={10,15l,1.5,"hello"}; for(auto& v: vec){// 1. void visitor, only called for side-effects (here, for I/O)std::visit([](auto&& arg){std::cout<< arg;}, v); // 2. value-returning visitor, demonstrates the idiom of returning another variant        value_t w=std::visit([](auto&& arg)-> value_t{return arg+ arg;}, v); // 3. type-matching visitor: a lambda that handles each type differentlystd::cout<<". After doubling, variant holds ";std::visit([](auto&& arg){using T=std::decay_t<decltype(arg)>;ifconstexpr(std::is_same_v<T,int>)std::cout<<"int with value "<< arg<<'\n';elseifconstexpr(std::is_same_v<T,long>)std::cout<<"long with value "<< arg<<'\n';elseifconstexpr(std::is_same_v<T,double>)std::cout<<"double with value "<< arg<<'\n';elseifconstexpr(std::is_same_v<T,std::string>)std::cout<<"std::string with value "<<std::quoted(arg)<<'\n';else                static_assert(false,"non-exhaustive visitor!");}, w);} for(auto& v: vec){// 4. another type-matching visitor: a class with 3 overloaded operator()'s// Note: The `(auto arg)` template operator() will bind to `int` and `long`//       in this case, but in its absence the `(double arg)` operator()//       *will also* bind to `int` and `long` because both are implicitly//       convertible to double. When using this form, care has to be taken//       that implicit conversions are handled correctly.std::visit(overloaded{[](auto arg){std::cout<< arg<<' ';},[](double arg){std::cout<<std::fixed<< arg<<' ';},[](conststd::string& arg){std::cout<<std::quoted(arg)<<' ';}}, v);}}

10. After doubling, variant holds int with value 2015. After doubling, variant holds long with value 301.5. After doubling, variant holds double with value 3hello. After doubling, variant holds std::string with value "hellohello"10 15 1.500000 "hello"