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

NAME
     std::ptr_fun - std::ptr_fun

Synopsis
	Defined in header <functional>
	template< class Arg, class Result >
							      (deprecated     in
     C++11)
	std::pointer_to_unary_function<Arg,Result>	  (1) (removed in C++17)

	    ptr_fun( Result (*f)(Arg) );
	template< class Arg1, class Arg2, class Result >
							      (deprecated     in
     C++11)
	std::pointer_to_binary_function<Arg1,Arg2,Result> (2) (removed in C++17)

	    ptr_fun( Result (*f)(Arg1, Arg2) );

	Creates a function wrapper object (either std::pointer_to_unary_function
     or
	std::pointer_to_binary_function), deducing the target type from the tem-
     plate
	arguments.

	1) Effectively calls std::pointer_to_unary_function<Arg,Result>(f).
	2)   Effectively   calls   std::pointer_to_binary_function<Arg1,Arg2,Re-
     sult>(f).

	This function and the related types are deprecated as of C++11 in  favor
     of the more
	general  std::function and std::ref, both of which create callable adap-
     tor-compatible
	function objects from plain functions.

Parameters
	f - pointer to a function to create a wrapper for

Return value
	A function object wrapping f.

Exceptions
	May throw implementation-defined exceptions.

Example
     // Run this code

      #include <algorithm>
      #include <functional>
      #include <iostream>
      #include <string_view>

      constexpr bool is_vowel(char c)
      {
	  return	    std::string_view{"aeoiuAEIOU"}.find(c)	      !=
     std::string_view::npos;
      }

      int main()
      {
	  std::string_view s = "Hello, world!";
	  std::ranges::copy_if(s, std::ostreambuf_iterator<char>(std::cout),
	      std::not1(std::ptr_fun(is_vowel)));
      #if 0
      // C++11 alternatives:
	      std::not1(std::cref(is_vowel)));
	      std::not1(std::function<bool(char)>(is_vowel)));
	      [](char c) { return !is_vowel(c); });
      // C++17 alternatives:
	      std::not_fn(is_vowel));
      #endif
      }

Output:
      Hll, wrld!

See also
	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)
	invoke		   invokes any Callable object with given arguments
	invoke_r	   and possibility to specify return type
	(C++17) 	   (since C++23)
	(C++23) 	   (function template)
	not_fn		   creates a function object that returns the complement
     of the
	(C++17) 	   result of the function object it holds
			   (function template)

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