std::monostate(3)

NAME
std::monostate - std::monostate

Synopsis
   Defined in header <variant>
   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 trivial implicit default/copy/move constructor
   (implicitly declared) (public member function)
   destructor trivial implicit destructor
   (implicitly declared) (public member function)
   operator= trivial implicit copy/move assignment
   (implicitly declared) (public member function)

Non-member functions
std::operator==, !=, <, <=, >, >=, <=>(std::monostate)
   constexpr bool operator==( monostate, monostate ) (1) (since C++17)
   noexcept { return true; }
   constexpr bool operator!=( monostate, monostate )
   noexcept { return false; }
   constexpr bool operator< ( monostate, monostate )
   noexcept { return false; }
   constexpr bool operator> ( monostate, monostate ) (since C++17)
   noexcept { return false; } (until C++20)
   constexpr bool operator<=( monostate, monostate )
   noexcept { return true; }
                        (2)
   constexpr bool operator>=( monostate, monostate )
   noexcept { return true; }
   constexpr std::strong_ordering operator<=>(
   monostate, monostate ) noexcept
   { (since C++20)
       return std::strong_ordering::equal;
   }
   All instances of std::monostate compare equal.
   The <, <=, >, >=, and != operators are synthesized from operator<=> (since C++20)
   and operator== respectively.

Helper classes
std::hash<std::monostate>
   template <> (since C++17)
   struct std::hash<monostate>;
   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
   constructor constructs the variant object
                 (public member function)