Namespaces
Variants

    std::monostate

    Von de.cppreference.net
     
    C++
     
    Hilfsprogramm-Bibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Hilfsprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-Vergleich
    (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)

    Allgemeine Hilfsprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap- und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::variant
     
    Definiert in Header <variant>
    Definiert in Header <utility>
    (seit C++26)
    		 
    struct monostate { };
    		(seit C++17)

    Einheitstyp, der für die Verwendung als wohlgeformte leere Alternative in std::variant vorgesehen ist. Insbesondere kann ein Variant aus nicht standardmäßig konstruierbaren Typen std::monostate als seine erste Alternative aufführen: Dadurch wird die Variante selbst standardmäßig konstruierbar.

    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)