std::experimental::function::function(3)

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

Synopsis
                        (library function() noexcept; (1) fundamentals
                        TS) function( (library std::nullptr_t ) (2) fundamentals noexcept; TS) function( 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::allocator_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::allocator_arg_t, fundamentals const Alloc& alloc, TS) std::nullptr_t ) noexcept; function( std::allocator_arg_t, const allocator_type& (library alloc, fundamentals
                        TS v3) std::nullptr_t ) noexcept; template< class Alloc > function( (library 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 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() (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 directly 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 instance 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::reference_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