Namespaces
Variants

std:: monostate

From cppreference.net
C++
Utilities library
std::variant
Definido en el encabezado <variant>
Definido en el encabezado <utility>
(desde C++26)
struct monostate { } ;
(desde C++17)

Tipo de unidad diseñado para ser utilizado como una alternativa vacía bien comportada 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 variant sea construible por defecto.

Contenidos

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)