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)

	  std::not1 is a helper	function to create a function object that  re-
       turns the
	  complement  of the unary predicate function passed. The function ob-
       ject 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 <functional>
	#include <iostream>
	#include <iterator>
	#include <numeric>
	#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(std::begin(v), std::end(v), 0);

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

	    // the same	as above 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		  2024.06.10			  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.1.quarterly>

home | help