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)  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)

http://cppreference.com		  2022.07.31		     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.0>

home | help