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

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

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

     function(						  (library  std::alloca-
     tor_arg_t, 			       fundamentals  const Alloc& alloc,
     TS)

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

     function(								(library
     std::allocator_arg_t,					       fundamen-
     tals 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  con-
     structor does
	not participate in overload resolution unless f is Callable for argument
     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 below).
	(until library fundamentals TS v3)

	After  construction  via  (1-5), this->get_memory_resource()	    (li-
     brary
	returns the same value as					  funda-
     mentals TS)
	std::experimental::pmr::get_default_resource()	during		  (until
     library
	construction.							  funda-
     mentals TS v3)
	After  construction  via  (1-3) and (5), *this stores a default     (li-
     brary
	constructed std::pmr::polymorphic_allocator<>.			  funda-
     mentals 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 directly
     stored inside
	the std::experimental::function  object,  no  dynamic  allocation  takes
     place. Other
	large  objects	may  be constructed in dynamic allocated storage and ac-
     cessed 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 us-
     ing-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 excep-
     tion 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)
home | help