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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::not1 - std::not1

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

	  not1 is a helper function to create a	function object	 that  returns
       the complement of
	  the  unary predicate function	passed.	The function object created is
       of type
	  std::unary_negate<Predicate>.

	  The unary predicate type must	define a member	 type,	argument_type,
       that is
	  convertible  to  the	predicate's parameter type. The	unary function
       objects obtained
	  from	  std::ref,    std::cref,    std::negate,    std::logical_not,
       std::mem_fn, std::function,
	  std::hash, or	from another call to std::not1 have this type defined,
       as are function
	  objects derived from the deprecated std::unary_function.

Parameters
	  pred - unary predicate

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

Exceptions
	  None.

Example
       // Run this code

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

	struct LessThan7 : std::unary_function<int, bool>
	{
	    bool operator()(int	i) const { return i < 7; }
	};

	int main()
	{
	    std::vector<int> v(10);
	    std::iota(begin(v),	end(v),	0);

	    std::cout	     <<	       std::count_if(begin(v),	       end(v),
       std::not1(LessThan7())) << "\n";

	    //same as above, but using `std::function`
	    std::function<bool(int)> less_than_9 = [](int x){ return x < 9; };
	    std::cout	      <<	std::count_if(begin(v),	       end(v),
       std::not1(less_than_9)) << "\n";
	}

Output:
	3
	1

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)
	  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)
	  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_function	adaptor-compatible unary function base class
	  (deprecated in C++11)	(class template)
	  (removed in C++17)

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

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

home | help