std:: monostate

From cppreference.com
C++
Utilities library
General utilities
Relational operators (deprecated in C++20)
std::variant
Defined in header <variant>
Defined in header <utility>
(since C++26)
struct monostate { } ;
(since C++17)

Unit type intended for use as a well-behaved empty alternative in std::variant . In particular, a variant of non-default-constructible types may list std::monostate as its first alternative: this makes the variant itself default-constructible.

Member functions

(constructor)
(implicitly declared)
trivial implicit default/copy/move constructor
(public member function)
(destructor)
(implicitly declared)
trivial implicit destructor
(public member function)
operator=
(implicitly declared)
trivial implicit copy/move assignment
(public member function)

Non-member functions

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

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

{
return std :: strong_ordering :: equal ;

}
(since C++20)

All instances of std::monostate compare equal.

The < , <= , > , >= , and != operators are synthesized from operator <=> and operator == respectively.

(since C++20)

Helper classes

std:: hash <std::monostate>

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

Specializes the std::hash algorithm for std::monostate .

Example

Run this code 
#include <cassert>
#include <iostream>
#include <variant>
 
struct S
{
    S(int i) : i(i) {}
    int i;
};
 
int main()
{
    // Without the monostate type this declaration will fail.
    // This is because S is not default-constructible.
    std::variant<std::monostate, S> var;
    assert(var.index() == 0);
 
    try
    {
        std::get<S>(var); // throws! We need to assign a value
    }
    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';
}

Possible output: 

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

See also

constructs the variant object
(public member function)
Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/utility/variant/monostate&oldid=177935 "