Namespaces
Variants

    std::monostate

    De es.cppreference.net
     
    C++
    Soporte de compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades del programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación tripartita
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
    Funciones de comparación de enteros
    (C++20)(C++20)(C++20)    
    (C++20)
    Operaciones de intercambio y tipo
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Tipos de vocabulario común
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::variant
     
    Definido en el encabezado <variant>
    Definido en el encabezado <utility>
    (desde C++26)
    		 
    struct monostate { };
    		(desde C++17)

    Tipo unidad destinado a ser usado como una alternativa vacía de buen comportamiento en std::variant. En particular, un variant de tipos no construibles por defecto puede incluir std::monostate como su primera alternativa: esto hace que el propio variant sea construible por defecto.

    Funciones miembro

    (constructor)
    (implicitly declared)
    		constructor trivial implícito por defecto/copia/movimiento
    (función miembro pública)
    (destructor)
    (implicitly declared)
    		destructor trivial implícito
    (función miembro pública)
    operator=
    (implicitly declared)
    		asignación de copia/movimiento trivial implícita
    (función miembro pública)

    Funciones no miembro

    std:: operator==, !=, <, <=, >, >=, <=> (std::monostate)

    constexpr bool operator == ( monostate, monostate ) noexcept { return true ; }
    		(1) (desde C++17)
    (2)
    constexpr bool operator ! = ( monostate, monostate ) noexcept { return false ; }

    constexpr bool operator < ( monostate, monostate ) noexcept { return false ; }
    constexpr bool operator > ( monostate, monostate ) noexcept { return false ; }
    constexpr bool operator <= ( monostate, monostate ) noexcept { return true ; }

    constexpr bool operator >= ( monostate, monostate ) noexcept { return true ; }
    		(desde C++17)
    (hasta C++20)
    constexpr std:: strong_ordering operator <=> ( monostate, monostate ) noexcept

    {
    return std :: strong_ordering :: equal ;

    }
    		(desde C++20)

    Todas las instancias de std::monostate se comparan como iguales.

    Los operadores < , <= , > , >= , y != son sintetizados a partir de operator <=> y operator == respectivamente.

    		(desde C++20)

    Clases auxiliares

    std:: hash <std::monostate>

    template <>
    struct std:: hash < monostate > ;
    		(desde C++17)

    Especializa el algoritmo std::hash para std::monostate .

    Ejemplo

    Ejecutar este código 
    #include <cassert>
#include <iostream>
#include <variant>
struct S
{
    S(int i) : i(i) {}
    int i;
};
int main()
{
    // Sin el tipo monostate esta declaración fallará.
    // Esto se debe a que S no es construible por defecto.
    std::variant<std::monostate, S> var;
    assert(var.index() == 0);
    try
    {
        std::get<S>(var); // ¡lanza una excepción! Necesitamos asignar un valor
    {
    catch(const std::bad_variant_access& e)
    {
        std::cout << e.what() << '\n';
    }
    var = 42;
    std::cout << "std::get: " << std::get<S>(var).i << '\n'
              << "std::hash: " << std::hex << std::showbase
              << std::hash<std::monostate>{}(std::monostate{}) << '\n';
}

    Salida posible: 

    std::get: wrong index for variant
std::get: 42
std::hash: 0xffffffffffffe19f

    Véase también

    		construye el objeto variant
    (función miembro pública)