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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::function::function - std::function::function

Synopsis
	  function() noexcept;				  (1) (since C++11)
	  function( std::nullptr_t ) noexcept;		  (2) (since C++11)
	  function( const function& other );		  (3) (since C++11)
	  function(		 function&&		 other		    );
       (since C++11)
									    (un-
       til C++20)
	  function(	   function&&	     other	   )	     noexcept;
       (since C++20)
	  template<	class	 F    >					   (5)
       (since C++11)
	  function( F&&	f );
	  template<		   class		Alloc		     >
       (since C++11)
	  function(	std::allocator_arg_t,	 const	  Alloc&	   (6)
       (removed	in C++17)
	  alloc	) noexcept;
	  template< class Alloc	>

	  function(    std::allocator_arg_t,	const	 Alloc&		   (7)
       (since C++11)
	  alloc,
       (removed	in C++17)

		    std::nullptr_t ) noexcept;
	  template< class Alloc	>			  (4)

	  function(	std::allocator_arg_t,	 const	  Alloc&	   (8)
       (since C++11)
	  alloc,
       (removed	in C++17)

		    const function& other );
	  template< class Alloc	>

	  function(    std::allocator_arg_t,	const	 Alloc&		   (9)
       (since C++11)
	  alloc,
       (removed	in C++17)

		    function&& other );
	  template<	    class	 F,	   class	Alloc	     >
       (since C++11)
	  function(    std::allocator_arg_t,	const	 Alloc&		  (10)
       (removed	in C++17)
	  alloc, F f );

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

	  1,2) Creates an empty	std::function.
	  3) Copies the	target of other	to the target of *this.
	  If other is empty, *this will	be empty right after the call too.
	  4) Moves the target of other to the target of	*this.
	  If other is empty, *this will	be empty right after the call too.
	  other	is in a	valid but unspecified state right after	the call.
	  5)  Initializes the target with std::forward<F>(f). The target is of
       type
	  std::decay<F>::type.
	  If f is a null pointer to function, a	null pointer to	member,	or  an
       empty value of
	  some	std::function  specialization, *this will be empty right after
       the call.
	  This overload	participates in	overload resolution only if  all  fol-
       lowing conditions
	  are satisfied:

	    * std::is_same_v<std::remove_cvref_t<F>, std::function<R(Args...)>
       (since C++23)
	      is false.

	    *  An  lvalue of type std::decay<F>::type is callable for argument
       types Args... and
	      return type R.

	  If std::is_copy_constructible_v<std::decay_t<F>> or
	  std::is_constructible_v<std::decay_t<F>, F> is false,	the program is
       (since C++23)
	  ill-formed.

	  If F is not CopyConstructible, the behavior is undefined.
	  6-10)	Same as	(1-5) except that alloc	is used	to allocate memory for
       any internal
	  data structures that the std::function might use.

	  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::function object, no dynamic allocation takes	 place.	 Other
       large objects may
	  be  constructed  in  dynamic	allocated  storage and accessed	by the
       std::function object
	  through a pointer.

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

Type requirements
	  -
	  Alloc	must meet the requirements of Allocator.

Exceptions
	  3,8,9) 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 constructor used to copy or move the stored callable object.

	  4) Does not throw if other's target is a function pointer or a
	  std::reference_wrapper,  otherwise  may  throw std::bad_alloc	or any
       (until C++20)
	  exception thrown by the constructor used to copy or move the stored
	  callable object.

	  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.

Notes
	  std::function's allocator support was	poorly specified and inconsis-
       tently
	  implemented. Some implementations do not provide overloads (6-10) at
       all, some
	  provide the overloads	but ignore the	supplied  allocator  argument,
       and some	provide
	  the  overloads  and  use the supplied	allocator for construction but
       not when	the
	  std::function	is reassigned. As a result, allocator support was  re-
       moved in	C++17.

Example
	   This	section	is incomplete
	   Reason: no example

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	    Applied to	      Behavior as published	   Correct be-
       havior
	  LWG 2132 C++11      overloads	(5,10) might be	ambiguous constrained
	  LWG 2774 C++11      (5,10) performed an additional move eliminated

See also
	  constructor	constructs a new std::move_only_function object
	  (C++23)	(public	member function	of std::move_only_function)

Category:
	    * Todo no example

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

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

home | help