[func.wrap.func.con]

🔗

function() noexcept;

Postconditions: !*this.

🔗

function(nullptr_t) noexcept;

Postconditions: !*this.

🔗

function(const function& f);

Postconditions: !*this if !f; otherwise, the target object of *this is a copy of the target object of f.

Throws: Nothing if f's target is a specialization of reference_wrapper or a function pointer.

Otherwise, may throw bad_alloc or any exception thrown by the copy constructor of the stored callable object.

Recommended practice: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where f's target is an object holding only a pointer or reference to an object and a member function pointer.

🔗

function(function&& f) noexcept;

Postconditions: If !f, *this has no target; otherwise, the target of *this is equivalent to the target of f before the construction, and f is in a valid state with an unspecified value.

🔗

template<class F> function(F&& f);

Preconditions: FD meets the Cpp17CopyConstructible requirements.

Postconditions: !*this is true if any of the following hold:

(12.1)
f is a null function pointer value.
(12.2)
f is a null member pointer value.
(12.3)
remove_cvref_t<F> is a specialization of the function class template, and !f is true.

Otherwise, *this has a target object of type FD direct-non-list-initialized with std::forward<F>(f).

Throws: Nothing if FD is a specialization of reference_wrapper or a function pointer type.

Otherwise, may throw bad_alloc or any exception thrown by the initialization of the target object.

Recommended practice: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where f refers to an object holding only a pointer or reference to an object and a member function pointer.

🔗

template<class F> function(F) -> function<see below>;

Constraints: &F::operator() is well-formed when treated as an unevaluated operand and either

(16.1)
F::operator() is a non-static member function and decltype(&F::operator() is either of the form R(G::*)(A..) cv & ${o p t noexcept {o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}_{o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}}_{o p t noexcept {o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}_{o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}}$
(16.2)
F::operator() is a static member function and decltype(&F::operator() is of the form R(*)(A..) noexcept ${o p t .}_{o p t .}$

[Example 1: void f() { int i{5}; function g = [&](double) { return i; }; / deduces function<int(double)> } — end example]

🔗

function& operator=(const function& f);

Returns: *this.

🔗

function& operator=(function&& f);

Effects: Replaces the target of *this with the target of f.

Returns: *this.

🔗

function& operator=(nullptr_t) noexcept;

Returns: *this.

🔗

template<class F> function& operator=(F&& f);

Returns: *this.

🔗

template<class F> function& operator=(reference_wrapper<F> f) noexcept;

Returns: *this.

🔗

~function();

Effects: If *this != nullptr, destroys the target of this.

22 General utilities library [utilities]

22.10 Function objects [function.objects]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.3 Class template function [func.wrap.func]

22.10.17.3.2 Constructors and destructor [func.wrap.func.con]