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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::not2 - std::not2

Synopsis
	  Defined in header <functional>
	  template<  class Predicate >					  (un-
       til C++14)
	  std::binary_negate<Predicate>	not2(const Predicate& pred);
	  template<		 class		     Predicate		     >
       (since C++14)
	  constexpr std::binary_negate<Predicate> not2(const Predicate&	 (dep-
       recated in C++17)
	  pred);							  (re-
       moved in	C++20)

	  not2 is a helper function to create a	function object	 that  returns
       the complement of
	  the binary predicate function	passed.	The function object created is
       of type
	  std::binary_negate<Predicate>.

	  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
	  another  call	to std::not2 have these	types defined, as are function
       objects derived
	  from the deprecated std::binary_function.

Parameters
	  pred - binary	predicate

Return value
	  std::not2 returns an object of  type	std::binary_negate<Predicate>,
       constructed with
	  pred.

Exceptions
	  None.

Example
       // Run this code

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

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

	struct new_same
	{
	    bool operator()(int	a, int b) const	{ return a == b; }
	};

	bool same_fn(int a, int	b)
	{
	    return a ==	b;
	}

	int main()
	{
	    std::vector<int> v1{0, 1, 2};
	    std::vector<int> v2{2, 1, 0};
	    std::vector<bool> v3(v1.size());

	    std::cout << "negating a binary_function:\n";
	    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
			   std::not2(old_same()));

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

	    std::cout << "negating a standard functor:\n";
	    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
			   std::not2(std::equal_to<int>()));

	    for	(std::size_t i = 0; i <	v1.size(); ++i)
		std::cout << v1[i] << '	' << v2[i] << '	' << v3[i] << '\n';

	    std::cout << "negating a std::function:\n";
	    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
			   std::not2(std::func-
       tion<bool(int,int)>(new_same())));

	    for	(std::size_t i = 0; i <	v1.size(); ++i)
		std::cout << v1[i] << '	' << v2[i] << '	' << v3[i] << '\n';

	    std::cout << "negating a std::reference_wrapper:\n";
	    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
			   std::not2(std::ref(same_fn)));

	    for	(std::size_t i = 0; i <	v1.size(); ++i)
		std::cout << v1[i] << '	' << v2[i] << '	' << v3[i] << '\n';

	}

Output:
	negating a binary_function:
	0 2 true
	1 1 false
	2 0 true
	negating a standard functor:
	0 2 true
	1 1 false
	2 0 true
	negating a std::function:
	0 2 true
	1 1 false
	2 0 true
	negating a std::reference_wrapper:
	0 2 true
	1 1 false
	2 0 true

See also
	  not_fn		 Creates  a  function  object that returns the
       complement of the
	  (C++17)		result of the function object it holds
				(function template)
	  binary_negate		wrapper	function object	returning the  comple-
       ment of the binary
	  (deprecated in C++17)	predicate it holds
	  (removed in C++20)	(class template)
	  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)
	  not1			constructs custom std::unary_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)
	  binary_function	adaptor-compatible binary function base	class
	  (deprecated in C++11)	(class template)
	  (removed in C++17)

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

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

home | help