home | help 
std::binary_negate(3)	       C++ Standard Libary	   std::binary_negate(3)

NAME
     std::binary_negate - std::binary_negate

Synopsis
	Defined in header <functional>
	template< class Predicate >

	struct binary_negate
	    : public std::binary_function<
		Predicate::first_argument_type,   (until C++11)
		Predicate::second_argument_type,
		bool

	    >;
	template< class Predicate >		  (since C++11)
	struct binary_negate;			  (deprecated in C++17)
						  (removed in C++20)

	std::binary_negate is a wrapper function object returning the complement
     of the
	binary predicate it holds.

	The  binary  predicate	type  must  define two member types, first_argu-
     ment_type and
	second_argument_type, that are convertible to the predicate's  parameter
     types. The
	function  objects  obtained  from  std::owner_less, std::ref, std::cref,
     std::plus,
	std::minus, std::multiplies, std::divides, std::modulus, std::equal_to,
	std::not_equal_to,    std::greater,    std::less,    std::greater_equal,
     std::less_equal,
	std::logical_not,     std::logical_or,	   std::bit_and,    std::bit_or,
     std::bit_xor,
	std::mem_fn, std::map::value_comp, std::multimap::value_comp, std::func-
     tion, or from
	a call to std::not2 have these types defined, as  are  function  objects
     derived from
	the deprecated std::binary_function.

	std::binary_negate  objects  are easily constructed with helper function
     std::not2.

Member types
	Type		     Definition
	first_argument_type  Predicate::first_argument_type
	second_argument_type Predicate::second_argument_type
	result_type	     bool

Member functions
	constructor   constructs a new binary_negate object  with  the	supplied
     predicate
		      (public member function)
		      returns  the logical complement of the result of a call to
     the stored
	operator()    predicate
		      (public member function)

     std::binary_negate::binary_negate

	explicit  binary_negate(  Predicate  const&  pred  );		  (until
     C++14)
	constexpr  explicit  binary_negate(  Predicate	const&	pred  );  (since
     C++14)

	Constructs a std::binary_negate function object with the  stored  predi-
     cate pred.

Parameters
	pred - predicate function object

     std::binary_negate::operator()

	bool  operator()( first_argument_type const& x, 		    (un-
     til C++14)
			 second_argument_type const& y ) const;
	constexpr    bool    operator()(    first_argument_type    const&     x,
     (since C++14)
				   second_argument_type const& y ) const;

	Returns the logical complement of the result of calling pred(x, y).

Parameters
	x - first argument to pass through to predicate
	y - second argument to pass through to predicate

Return value
	The logical complement of the result of calling pred(x, y).

Example
     // Run this code

      #include <algorithm>
      #include <cstddef>
      #include <functional>
      #include <iostream>
      #include <vector>

      struct same : std::binary_function<int, int, bool>
      {
	  bool operator()(int a, int b) const { return a == b; }
      };

      int main()
      {
	  std::vector<int> v1;
	  for (int i = 0; i < 7; ++i)
	      v1.push_back(i);

	  std::vector<int> v2(v1.size());
	  std::reverse_copy(v1.begin(), v1.end(), v2.begin());

	  std::vector<bool> v3(v1.size());

	  std::binary_negate<same> not_same((same()));

	  // C++11 solution:
	  // std::function<bool (int, int)> not_same =
	  //	 [](int x, int y) -> bool { return !same()(x, y); };

	  std::transform(v1.begin(),	 v1.end(),    v2.begin(),    v3.begin(),
     not_same);

	  std::cout.setf(std::ios_base::boolalpha);
	  for (std::size_t i = 0; i != v1.size(); ++i)
	      std::cout << v1[i] << " != " << v2[i] << " : " << v3[i] << '\n';
      }

Output:
      0 != 6 : true
      1 != 5 : true
      2 != 4 : true
      3 != 3 : false
      4 != 2 : true
      5 != 1 : true
      6 != 0 : true

See also
	binary_function       adaptor-compatible binary function base class
	(deprecated in C++11) (class template)
	(removed in C++17)
	function	      wraps callable object of	any  copy  constructible
     type with
	(C++11) 	      specified function call signature
			      (class template)
	move_only_function     wraps  callable object of any type with specified
     function call
	(C++23) 	      signature
			      (class template)
	not2		      constructs custom std::binary_negate object
	(deprecated in C++17) (function template)
	(removed in C++20)
	ptr_fun 	       creates	an  adaptor-compatible	function  object
     wrapper from a
	(deprecated in C++11) pointer to function
	(removed in C++17)    (function template)
	unary_negate	       wrapper	function object returning the complement
     of the unary
	(deprecated in C++17) predicate it holds
	(removed in C++20)    (class template)

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