function(); | (1) | (since C++11) |

function( std::nullptr_t ); | (2) | (since C++11) |

function( const function& other ); | (3) | (since C++11) |

function( function&& other ); | (4) | (since C++11) |

template< class F > function( F f ); | (5) | (since C++11) |

template< class Alloc > function( std::allocator_arg_t, const Alloc& alloc ); | (6) | (since C++11) (until C++17) |

template< class Alloc > function( std::allocator_arg_t, const Alloc& alloc, std::nullptr_t ); | (7) | (since C++11) (until C++17) |

template< class Alloc > function( std::allocator_arg_t, const Alloc& alloc, const function& other ); | (8) | (since C++11) (until C++17) |

template< class Alloc > function( std::allocator_arg_t, const Alloc& alloc, function&& other ); | (9) | (since C++11) (until C++17) |

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

Constructs a `std::function`

from a variety of sources.

1-2) Creates an *empty* function.

3-4) Copies (3) or moves (4) the *target* of *target* of *empty*, *empty* after the call too. For (4),

`other`

to the `*this`

. If `other`

is `*this`

will be `other`

is in a valid but unspecified state after the call.
5) Initializes the *target* with a copy of *empty* after the call. This constructor does not participate in overload resolution unless f is

`f`

. If `f`

is a null pointer to function or null pointer to member, `*this`

will be `Callable`

for argument types `Args...`

and return type `R`

. (since C++14)
6-10) Same as (1-5) except that

`alloc`

is used to allocate memory for any internal data structures that the `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.

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` . |
||

-`Alloc` must meet the requirements of `Allocator` . |

1-2)

`noexcept`

specification: `noexcept`

3,4,8,9) does not throw if *target* is a function pointer or a

`other`

's `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.
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.
6-7)

`noexcept`

specification: `noexcept`

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/utility/functional/function/function