Namespaces
Variants

std:: monostate

From cppreference.net
C++
Utilities library
std::variant
Definiert in Header <variant>
Definiert in Header <utility>
(seit C++26)
struct monostate { } ;
(seit C++17)

Einheitstyp, der als wohlerzogene leere Alternative in std::variant verwendet werden soll. Insbesondere kann eine Variante von nicht-standardkonstruierbaren Typen std::monostate als erste Alternative auflisten: Dies macht die Variante selbst standardkonstruierbar.

Inhaltsverzeichnis

Memberfunktionen

(Konstruktor)
(implizit deklariert)
trivialer impliziter Standard-/Kopier-/Move-Konstruktor
(öffentliche Elementfunktion)
(Destruktor)
(implizit deklariert)
trivialer impliziter Destruktor
(öffentliche Elementfunktion)
operator=
(implizit deklariert)
triviale implizite Kopier-/Move-Zuweisung
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

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

constexpr bool operator == ( monostate, monostate ) noexcept { return true ; }
(1) (seit 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 ; }
(seit C++17)
(bis C++20)
constexpr std:: strong_ordering operator <=> ( monostate, monostate ) noexcept

{
return std :: strong_ordering :: equal ;

}
(seit C++20)

Alle Instanzen von std::monostate vergleichen gleich.

Die Operatoren < , <= , > , >= und != werden synthetisiert aus operator <=> bzw. operator == .

(seit C++20)

Hilfsklassen

std:: hash <std::monostate>

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

Spezialisiert den std::hash -Algorithmus für std::monostate .

Beispiel

Diesen Code ausführen 
#include <cassert>
#include <iostream>
#include <variant>
struct S
{
    S(int i) : i(i) {}
    int i;
};
int main()
{
    // Ohne den monostate-Typ würde diese Deklaration fehlschlagen.
    // Dies liegt daran, dass S nicht standardkonstruierbar ist.
    std::variant<std::monostate, S> var;
    assert(var.index() == 0);
    try
    {
        std::get<S>(var); // wirft eine Exception! Wir müssen einen Wert zuweisen
    }
    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';
}

Mögliche Ausgabe: 

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

Siehe auch

konstruiert das variant Objekt
(public member function)