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

FreeBSD Manual Pages

  
 
  

home | help
std::experi...on::function(3) C++ Standard Libarystd::experi...on::function(3)

NAME
       std::experimental::function::function	 -    std::experimental::func-
       tion::function

Synopsis
				 (library function() noexcept;	(1)  fundamen-
       tals
				 TS)	 function(		      (library
       std::nullptr_t )	     (2)  fundamentals	noexcept;		   TS)
       function(  const		  (library function& other );	 (3) fundamen-
       tals
				 TS) function( function&&      (library	 other
       );	       (4) fundamentals
				 TS)  template<	class F	>	(library func-
       tion( F f );	 (5) fundamentals
				 TS)	 template<     class	  Alloc	     >
       (library	function(			       fundamentals std::allo-
       cator_arg_t,		      TS) const	Alloc& alloc ) noexcept; func-
       tion( std::allocator_arg_t,		    (library
		 const			      fundamentals allocator_type& al-
       loc		    TS v3) ) noexcept; template< class Alloc >

       function(					   (library std::allo-
       cator_arg_t,				   fundamentals	 const	Alloc&
       alloc,				      TS)

       std::nullptr_t  ) noexcept; function( std::allocator_arg_t, const allo-
       cator_type&					(library	alloc,
       fundamentals
							   TS		   v3)
       std::nullptr_t )	noexcept; template< class Alloc	>

       function(							  (li-
       brary						 std::allocator_arg_t,
       fundamentals	    const	  Alloc&	 alloc,		   (6)
       TS)

		 const	function&  other  );  function(	 std::allocator_arg_t,
       (library		   const	    allocator_type&		   (7)
       fundamentals							alloc,
       TS v3)
		 const function& other ); template< class Alloc	>

       function(
       (library		  std::allocator_arg_t,				   (8)
       fundamentals		 const		    Alloc&		alloc,
       TS)

		 function&&   other   );    function(	 std::allocator_arg_t,
       (library			     const		       allocator_type&
       fundamentals  alloc,						   (9)
       TS v3)
		 function&&   other  );	 template<  class  F,  class  Alloc  >
       (library							     function(
       fundamentals					 std::allocator_arg_t,
       TS)	      const	       Alloc&		  alloc,	     F
       (10)		      f			 );		     function(
       (library						 std::allocator_arg_t,
       fundamentals		       const		       allocator_type&
       TS v3) alloc, F f );

	  Constructs a std::experimental::function from	a variety of sources.

	  1,2) Creates an empty	function.
	  3) Copies the	target of other	to the target of *this.	 If  other  is
       empty, *this will
	  be empty after the call too.
	  4)  Moves  the  target  of other to the target of *this. If other is
       empty, *this will
	  be empty after the call too.
	  After	construction, *this stores a copy of other.get_allocator().
	  (library fundamentals	TS v3)
	  5) Initializes the target with a copy	of f. If f is a	 null  pointer
       to function or
	  null	pointer	 to  member,  *this will be empty after	the call. This
       constructor does
	  not participate in overload resolution unless	f is Callable for  ar-
       gument types
	  Args... and return type R.
	  6-10)	Same as	(1-5) except that alloc	is used	to allocate memory for
       any internal
	  data structures that the function might use.
	  These	 constructors  treat alloc as a	type-erased allocator (see be-
       low).
	  (until library fundamentals TS v3)

	  After	  construction	  via	 (1-5),	   this->get_memory_resource()
       (library
	  returns	     the	    same	    value	    as
       fundamentals TS)
	  std::experimental::pmr::get_default_resource()		during
       (until library
	  construction.
       fundamentals TS v3)
	  After	 construction  via  (1-3)  and	(5),  *this  stores  a default
       (library
	  constructed			    std::pmr::polymorphic_allocator<>.
       fundamentals TS v3)

	  When	the  target is a function pointer or a std::reference_wrapper,
       small object
	  optimization is guaranteed, that is, these targets  are  always  di-
       rectly stored inside
	  the  std::experimental::function object, no dynamic allocation takes
       place. Other
	  large	objects	may be constructed in dynamic  allocated  storage  and
       accessed	by the
	  std::experimental::function object through a pointer.

	  If a constructor moves or copies a function object, including	an in-
       stance of
	  std::experimental::function,	then that move or copy is performed by
       using-allocator
	  construction with allocator
	  this->get_memory_resource()
	  (until library fundamentals TS v3)
	  this->get_allocator()
	  (library fundamentals	TS v3).

Parameters
	  other	   -   the function object used	to initialize *this
	  f	   -   a callable used to initialize *this
	  alloc	   -   an allocator used for internal memory allocation

Type requirements
	  -
	  F must meet the requirements of Callable and CopyConstructible.

Exceptions
	  3,8) Does not	throw if other's target	is a function pointer or a
	  std::reference_wrapper, otherwise may	throw  std::bad_alloc  or  any
       exception thrown
	  by the copy constructor of the stored	callable object.
	  4) (none)
	  5,10)	 Does  not  throw  if f	is a function pointer or a std::refer-
       ence_wrapper,
	  otherwise may	throw std::bad_alloc or	any exception  thrown  by  the
       copy constructor
	  of the stored	callable object.
	  9) (none)

Example
	   This	section	is incomplete
	   Reason: no example

Category:
	    * Todo no example

http://cppreference.com		  2024.06.10	 std::experi...on::function(3)

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

home | help