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)
									  (until
     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)	    (re-
     moved in C++17)
	alloc ) noexcept;
	template< class Alloc >

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

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

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

		  const function& other );
	template< class Alloc >

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

		  function&& other );
	template< class F, class Alloc >				  (since
     C++11)
	function(  std::allocator_arg_t,  const Alloc&	      (10)	    (re-
     moved 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  following
     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 directly
     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 excep-
     tion 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  removed
     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 behavior
	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)
home | help