std::variant - cppreference.com

La plantilla de clase std::variant representa un tipo variante: una union de tipo seguro. Una instancia de std::variant en cualquier tiempo dado mantiene ya sea o valor a uno de sus tipos alternos, o en el caso de error, ningún valor (este estado es difícil de alcanzar, véase valueless_by_exception).

Al igual que con las uniones, si un variante tiene un valor de algún tipo de objeto T, la representación del objeto de T se asigna directamente dentro de la representación del objeto del variante mismo. El variante no tiene permitido asignar memoria adicional (dinámica).

No se permite que un variante contenga referencias, arrays o el tipo void. Los variantes vacíos también están mal formados (std::variant<std::monostate> puede usarse en su lugar).

Se permite que un variante contenga el mismo tipo más de una vez, y que contenga versiones calificadas-cv diferentes del mismo tipo.

De acuerdo con el comportamiento de las uniones durante inicialización de agregado, un variante construido por defecto tiene un valor de su primera alternativa, a menos que esa alternativa no sea construible por defecto (en cuyo caso el variante tampoco es construible por defecto). La clase auxiliar std::monostate puede usarse para hacer que tales variantes sean construibles por defecto.

Parámetros de plantilla

Funciones miembro

Funciones no miembro

Clases auxiliares

Objetos auxiliares

Ejemplo

#include <variant>
#include <string>
#include <cassert>
#include <iostream>

int main()
{
    std::variant<int, float> v, w;
    v = 42; // v contiene int
    int i = std::get<int>(v);
    assert(42 == i);      // tiene éxito
    w = std::get<int>(v);
    w = std::get<0>(v);   // el mismo efecto que la línea anterior
    w = v;                // el mismo efecto que la línea anterior

//  std::get<double>(v);  // ERROR: no hay un double en [int, float]
//  std::get<3>(v);       // ERROR: valores válidos de subíndices son 0 y 1

    try {
      std::get<float>(w); // w contiene int, no float: lanzará
    }
    catch (const std::bad_variant_access& ex) {
      std::cout << ex.what() << '\n';  
    }

    using namespace std::literals;

    std::variant<std::string> x("abc");
    // constructores de conversión funcionan cuando existe ambigüedad
    x = "def"; // asignación de conversión también funciona cuando existe ambigüedad

    std::variant<std::string, void const*> y("abc");
    // convierte a void const * cuando se pasa un char const *
    assert(std::holds_alternative<void const*>(y)); // tiene éxito
    y = "xyz"s;
    assert(std::holds_alternative<std::string>(y)); // tiene éxito
}

std::get: wrong index for variant

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

Véase también