std::variant

template< class... Types >
class variant;

La plantilla de clase std::variant representa una unión segura en cuanto a tipos.

Una instancia de variant en cualquier momento dado contiene un valor de uno de sus tipos alternativos, 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 una variant contiene un valor de algún tipo de objeto T, el objeto T está anidado dentro del objeto variant.

No se permite que una variant contenga referencias, arreglos o el tipo void.

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

De acuerdo con el comportamiento de las uniones durante la inicialización agregada, una variant construida por defecto contiene un valor de su primera alternativa, a menos que esa alternativa no se pueda construir por defecto (en cuyo caso la variant tampoco se puede construir por defecto). La clase auxiliar std::monostate se puede usar para hacer que dichas variants se puedan construir por defecto.

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

Si un programa declara una especialización explícita o 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