std::visit

#include <iomanip>
#include <iostream>
#include <string>
#include <type_traits>
#include <variant>
#include <vector>

// variant для visit
using var_t = std::variant<int, long, double, std::string>;

// вспомогательная константа для посетителя #3
template<class>
inline constexpr bool always_false_v = false;

// вспомогательный тип для посетителя #4
template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
// явные правила вывода (не требуется, начиная с C++20)
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

int main()
{
    std::vector<var_t> vec = {10, 15l, 1.5, "привет"};
    
    for (auto& v: vec)
    {
        // 1. посетитель void, вызываемый только для побочных эффектов
        // (здесь для ввода/вывода)
        std::visit([](auto&& arg){ std::cout << arg; }, v);
        
        // 2. посетитель, возвращающий значение, демонстрирует идиому
        // возврата другого variant
        var_t w = std::visit([](auto&& arg) -> var_t { return arg + arg; }, v);
        
        // 3. посетитель, соответствующий типу: лямбда, которая обрабатывает
        // каждый тип по-разному
        std::cout << ". После удвоения variant хранит ";
        std::visit([](auto&& arg)
        {
            using T = std::decay_t<decltype(arg)>;
            if constexpr (std::is_same_v<T, int>)
                std::cout << "int с значением " << arg << '\n';
            else if constexpr (std::is_same_v<T, long>)
                std::cout << "long с значением " << arg << '\n';
            else if constexpr (std::is_same_v<T, double>)
                std::cout << "double с значением " << arg << '\n';
            else if constexpr (std::is_same_v<T, std::string>)
                std::cout << "std::string с значением " << std::quoted(arg) << '\n';
            else 
                static_assert(always_false_v<T>, "неисчерпывающий посетитель!");
        }, w);
    }
    
    for (auto& v: vec)
    {
        // 4. другой посетитель с сопоставлением типов: класс с 3-мя
        // перегруженными operator()
        // Примечание: Шаблон `(auto arg)` operator() будет привязан к `int` и `long`
        //             в этом случае, но в его отсутствие `(double arg)` operator()
        //             *также* будет привязан к `int` и `long`, потому что оба неявно
        //             преобразуются в double. При использовании этой формы
        //             необходимо следить за тем, чтобы неявные преобразования
        //             обрабатывались правильно.
        std::visit(overloaded{
            [](auto arg) { std::cout << arg << ' '; },
            [](double arg) { std::cout << std::fixed << arg << ' '; },
            [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; }
        }, v);
    }
}