Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::monostate&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help