std::variant

std::variant<T1, T2, ...> хранит значение ровно одного из типов T1, T2, ... в конкретный момент времени, и всегда знает, какой именно — в отличие от сырого union. Доступ к активному значению — через std::get<T>(v) (кидает std::bad_variant_access, если активен другой тип), std::get_if<T>(&v) (возвращает указатель или nullptr, без исключений), либо std::visit — диспетчеризация по активному типу через вызываемый объект.std::variant<T1, T2, ...> holds a value of exactly one of the types T1, T2, ... at any given moment, and always knows which one — unlike a raw union. Access to the active value is through std::get<T>(v) (throws std::bad_variant_access if a different type is active), std::get_if<T>(&v) (returns a pointer or nullptr, no exceptions), or std::visit — dispatch on the active type via a callable object.

union Raw {
    int i;
    double d;
    // std::string s; — нельзя без ручного placement new/~string()// std::string s; — impossible without manual placement new/~string()
};

struct Tagged {
    enum { INT, DOUBLE } tag;  // ручной тег — легко забыть обновить// a manual tag — easy to forget to update
    union { int i; double d; };
};
// обращение не к тому члену union — UB, компилятор не проверяет// accessing the wrong union member is UB, the compiler doesn't check

std::variant<int, double, std::string> v = 42;

if (auto* p = std::get_if<int>(&v)) {
    use(*p);  // безопасно — тип проверен явно// safe — the type was checked explicitly
}

v = std::string("now a string");  // смена активного типа отслеживается автоматически// the active type change is tracked automatically
std::get<int>(v);  // кидает std::bad_variant_access — активен string, не int// throws std::bad_variant_access — string is active, not int

Сырой union в C++ решает задачу «одна из нескольких альтернатив» лишь частично, оставляя две дыры:A raw union in C++ solves the "one of several alternatives" problem only partially, leaving two gaps:

std::visit — основной идиоматичный способ работать с variant без ручных if/switch по index(). Он вызывает переданный callable с активным значением, требуя, чтобы callable умел принять любой из типов variant. Частый идиом — overloaded: класс, наследующий сразу от нескольких лямбд и объединяющий их operator() через using, чтобы получить один объект, перегруженный по каждому типу.std::visit is the main idiomatic way to work with a variant without manual if/switch on index(). It calls the given callable with the active value, requiring the callable to accept any of the variant's types. A common idiom is overloaded: a class that inherits from several lambdas at once and merges their operator() via using, producing a single object overloaded per type.

// idiom "overloaded" — объединение нескольких лямбд в один visitor// the "overloaded" idiom — merging several lambdas into one visitor
template <class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };

template <class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;  // deduction guide (см. CTAD)// deduction guide (see CTAD)

std::variant<int, double, std::string> v = "hi";

std::visit(overloaded{
    [](int i)             { std::cout << "int: " << i; },
    [](double d)          { std::cout << "double: " << d; },
    [](const std::string& s) { std::cout << "string: " << s; }
}, v);  // вызовется третья лямбда — активен string// the third lambda runs — string is active

Все ветки visitor обязаны возвращать один и тот же тип (или все — void) — компилятор должен статически знать единственный тип результата std::visit, вне зависимости от того, какая ветка реально выполнится в рантайме. Альтернатива нескольким лямбдам — одна generic-лямбда с if constexpr внутри, проверяющая тип через if constexpr (std::is_same_v<T, int>) и так далее.Every branch of the visitor must return the same type (or all must return void) — the compiler needs to statically know a single result type for std::visit, regardless of which branch actually executes at runtime. An alternative to multiple lambdas is a single generic lambda with if constexpr inside, checking the type via if constexpr (std::is_same_v<T, int>) and so on.

• cppreference — std::variant
• WG21 P0088 — Variant: a type-safe union (v5)