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) noexcept { return (since C++17)
   true; }
   constexpr bool operator!=(monostate, monostate) noexcept { return
   false; }
   constexpr bool operator<(monostate, monostate) noexcept { return
   false; }
   constexpr bool operator>(monostate, monostate) noexcept { return (since C++17)
   false; } (until C++20)
   constexpr bool operator<=(monostate, monostate) noexcept { return
   true; }
   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 <> struct std::hash<monostate>;
   Specializes the std::hash algorithm for std::monostate.

Example
// Run this code
 #include <variant>
 #include <iostream>
 #include <cassert>
 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 = 12;
     std::cout << std::get<S>(var).i << '\n';
 }

Possible output:
 std::get: wrong index for variant
 12

See also
   constructor constructs the variant object
                 (public member function)