std:: variant

La plantilla de clase std::variant representa una union type-safe.

Una instancia de variant en cualquier momento dado contiene un valor de uno de sus tipos alternativos, o en caso de error - ningún valor (este estado es difícil de alcanzar, ver valueless_by_exception ).

Al igual que con las uniones, si una variante contiene un valor de algún tipo de objeto T , el objeto T está anidado dentro del objeto variant .

Una variante no puede contener referencias, arrays o el tipo void .

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

De manera consistente con el comportamiento de las uniones durante la inicialización por agregado , un variant construido por defecto contiene un valor de su primera alternativa, a menos que esa alternativa no sea construible por defecto (en cuyo caso el variant tampoco es construible por defecto). La clase auxiliar std::monostate puede utilizarse para hacer que dichos variants sean construibles por defecto.

Un programa que instancia la definición de std::variant sin argumentos de plantilla está mal formado. std :: variant < std:: monostate > puede ser utilizado en su lugar.

Si un programa declara una especialización explícita o una especialización parcial de std::variant , el programa está mal formado, no se requiere diagnóstico.

Parámetros de plantilla

Funciones miembro

Funciones no miembro

Clases auxiliares

Objetos auxiliares

Notas

Ejemplo

#include <cassert>
#include <iostream>
#include <string>
#include <variant>
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); // mismo efecto que la línea anterior
    w = v; // mismo efecto que la línea anterior
//  std::get<double>(v); // error: no hay double en [int, float]
//  std::get<3>(v);      // error: los valores de índice válidos son 0 y 1
    try
    {
        std::get<float>(w); // w contiene int, no float: lanzará excepción
    }
    catch (const std::bad_variant_access& ex)
    {
        std::cout << ex.what() << '\n';
    }
    using namespace std::literals;
    std::variant<std::string> x("abc");
    // los constructores de conversión funcionan cuando son unívocos
    x = "def"; // la asignación de conversión también funciona cuando es unívoca
    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 que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también