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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::experimental::ranges::not_equal_to	      -	       std::experimen-
       tal::ranges::not_equal_to

Synopsis
	  Defined in header <experimental/ranges/functional>
	  template< class T = void >

	  requires EqualityComparable<T> ||
	  Same<T,			    void>			    ||
       (ranges TS)
	  /* ==	on two const T lvalues invokes a built-in operator comparing
	  pointers */

	  struct not_equal_to;
	  template							    <>
       (ranges TS)
	  struct not_equal_to<void>;

	  Function object for performing comparisons. The primary template in-
       vokes operator ==
	  on const lvalues of type T and negates the result.  The  specializa-
       tion
	  not_equal_to<void>  deduces the parameter types of the function call
       operator	from
	  the arguments	(but not the return type).

	  All specializations of not_equal_to are Semiregular.

Member types
	  Member							  type
       Definition
	  is_transparent (member only of not_equal_to<void> specialization) /*
       unspecified */

Member functions
	  operator() checks if the arguments are not equal
		     (public member function)

       std::experimental::ranges::not_equal_to::operator()

	  constexpr  bool  operator()(const  T&	x, const   (1) (member only of
       primary
	  T&  y)  const;				       not_equal_to<T>
       template)
	  template< class T, class U >

	  requires EqualityComparableWith<T, U>	||
	  /*  std::declval<T>()	 ==  std::declval<U>()	       (member only of
       not_equal_to<void>
	  resolves to					(2) specialization)
	  a built-in operator comparing	pointers */

	  constexpr bool operator()(T&&	t, U&& u)
	  const;

	  1) Compares x	and y. Equivalent to  return  !ranges::equal_to<>{}(x,
       y);
	  2)	 Compares     t	    and	    u.	   Equivalent	  to	return
       !ranges::equal_to<>{}(std::forward<T>(t),
	  std::forward<U>(u));.

Notes
	  Unlike std::not_equal_to, ranges::not_equal_to requires both ==  and
       != to be	valid
	  (via the EqualityComparable and EqualityComparableWith constraints),
       and is entirely
	  defined in terms of ranges::equal_to.	However, the implementation is
       free to use
	  operator!=  directly,	 because those concepts	require	the results of
       == and != to be
	  consistent.

Example
	   This	section	is incomplete
	   Reason: no example

See also
	  not_equal_to function	object implementing x != y
		       (class template)

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

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

home | help