home | help 
std::monostate(3)	       C++ Standard Libary	       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-con-
     structible.

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)

http://cppreference.com 	   2024.06.10		       std::monostate(3)
home | help