Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::variant — uno de un conjunto fijo de tipos alternativos

std::variant almacena un valor de uno de los tipos alternativos especificados por sus parámetros de plantilla y gestiona su duración. Permite modelar datos como «número o texto» y comprobar y manejar de forma segura la alternativa activa.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <variant>
std::variant<Types...> value;
std::get<T>(value);
std::get_if<T>(&value);
std::visit(visitor, value);

std::variant<Types...> de <variant> representa un conjunto cerrado de tipos alternativos. El valor contenido está dentro del objeto; solo una alternativa está activa a la vez, salvo en el estado sin valor que se describe más abajo. La construcción predeterminada inicializa con un valor la primera alternativa y exige que esta se pueda construir por defecto. Una primera alternativa de tipo std::monostate puede representar un estado vacío intencionado.

index() devuelve el índice, empezando por cero, de la alternativa activa. std::get<T>(value) devuelve una referencia si está activa la alternativa de tipo T. Lanza std::bad_variant_access si está activa otra alternativa o si no hay ninguna activa. std::get_if<T>(&value) devuelve un puntero o nullptr, sin lanzar excepciones. El acceso por tipo requiere que ese tipo aparezca exactamente una vez en la lista de alternativas; si hay tipos repetidos, usa el acceso por índice, como std::get<0>(value).

std::visit(visitor, value) invoca un objeto invocable con el valor activo. El objeto debe admitir todas las alternativas; en la forma de llamada mostrada, todos los resultados posibles deben tener el mismo tipo y la misma categoría de valor. Una asignación o emplace puede cambiar la alternativa activa. Una excepción durante algunas de estas operaciones puede dejar el objeto sin valor: entonces valueless_by_exception() devuelve true, index() devuelve std::variant_npos y tanto std::get como std::visit lanzan std::bad_variant_access. Esto es distinto de almacenar std::monostate.

El ejemplo primero lee un int, luego lo sustituye por un std::string y maneja el valor mediante std::visit. Esta entrada está dirigida a C++23; ese estándar se basa en la opción del compilador del repositorio, no en un entorno de producción verificado. La fuente es un borrador de trabajo en evolución y también puede contener características posteriores.

Ejemplos

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

int main() {
    std::variant<int, std::string> value{42};
    if (const auto* number = std::get_if<int>(&value)) {
        std::cout << *number << '\n';
    }

    value = std::string{"ready"};
    std::cout << value.index() << '\n';
    std::visit([](const auto& item) {
        std::cout << item << '\n';
    }, value);
}

Resultado

42
1
ready

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes