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

FreeBSD Manual Pages

  
 
  

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)

	  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 para-
       meter 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::function, or from
	  a call to std::not2 have these types defined,	as  are	 function  ob-
       jects derived from
	  the deprecated std::binary_function.

	  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  sup-
       plied 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)
	  explicit constexpr binary_negate( Predicate const& pred  );	(since
       C++14)

	  Constructs a binary_negate function object with the stored predicate
       pred.

Parameters
	  pred - predicate function object

       std::binary_negate::operator()

	  bool	operator()(  first_argument_type  const&  x,		(until
       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 <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;
	    std::vector<int> v2;
	    for	(int i = 0; i <	10; ++i) v1.push_back(i);
	    for	(int i = 0; i <	10; ++i) v2.push_back(10 - i);

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

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

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

	    /* C++11 solution:
		// Use std::function<bool (int,	int)>
		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	(int i = 0; i <	10; ++i)
		std::cout << v1[i] << '	' << v2[i] << '	' << v3[i] << '\n';
	}

Output:
	0 10 true
	1 9 true
	2 8 true
	3 7 true
	4 6 true
	5 5 false
	6 4 true
	7 3 true
	8 2 true
	9 1 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  con-
       structible type with
	  (C++11)		specified function call	signature
				(class template)
	  move_only_function	wraps callable object of any type with	speci-
       fied 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  comple-
       ment of the unary
	  (deprecated in C++17)	predicate it holds
	  (removed in C++20)	(class template)

http://cppreference.com		  2022.07.31		 std::binary_negate(3)

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

home | help