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

FreeBSD Manual Pages

  
 
  

home | help 
std::experi...nges::Common(3) C++ Standard Libarystd::experi...nges::Common(3)

NAME
       std::experimental::ranges::Common - std::experimental::ranges::Common

Synopsis
	  Defined in header <experimental/ranges/concepts>
	  template <class T, class U>

	  concept bool Common =
	  Same<ranges::common_type_t<T,	U>, ranges::common_type_t<U, T>> &&
	  ConvertibleTo<T, ranges::common_type_t<T, U>>	&&
	  ConvertibleTo<U, ranges::common_type_t<T, U>>	&&
	  CommonReference<
	  std::add_lvalue_reference_t<const				   T>,
       (ranges TS)
	  std::add_lvalue_reference_t<const U>>	&&
	  CommonReference<
	  std::add_lvalue_reference_t<ranges::common_type_t<T, U>>,
	  ranges::common_reference_t<
	  std::add_lvalue_reference_t<const T>,

	  std::add_lvalue_reference_t<const U>>>;

	  The concept Common<T,	U> specifies that two types T and  U  share  a
       common type (as
	  computed by ranges::common_type_t) to	which both can be converted.

	  Common<T,  U>	 is  satisfied only if,	given expressions t and	u such
       that decltype((t))
	  is T and decltype((u)) is U,

	    *  ranges::common_type_t<T,	 U>(t)	is   equal   to	  ranges::com-
       mon_type_t<T, U>(t) if and
	      only if t	is an equality-preserving expression; and
	    *	ranges::common_type_t<T,   U>(u)   is  equal  to  ranges::com-
       mon_type_t<T, U>(u) if and
	      only if u	is an equality-preserving expression.

	  In other words, the conversion to the	common type must not alter the
	  equality-preservation	property of the	original expression.

	 Equality preservation

	  An expression	is equality preserving if it results in	equal  outputs
       given equal
	  inputs.

	    * The inputs to an expression consist of its operands.
	    *  The  outputs  of	 an  expression	 consist of its	result and all
       operands	modified by
	      the expression (if any).

	  Every	expression required to be equality preserving is  further  re-
       quired to be
	  stable:  two	evaluations  of	such an	expression with	the same input
       objects must have
	  equal	outputs	absent any explicit intervening	modification of	 those
       input objects.

See also
	  common_type	   determine the common	type of	a set of types
			   (class template)
	  common_reference  determine  the  common  reference type of a	set of
       types
			   (class template)
	  CommonReference  specifies that two types share a  common  reference
       type
			   (concept)

http://cppreference.com		  2022.07.31	 std::experi...nges::Common(3)

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

home | help