23 General utilities library [utilities]

23.14 Function objects [function.objects]

23.14.13 Polymorphic function wrappers [func.wrap]

23.14.13.2 Class template function [func.wrap.func]

23.14.13.2.1 function construct/copy/destroy [func.wrap.func.con]

function() noexcept;

Postconditions: !*this.

🔗

function(nullptr_t) noexcept;

Postconditions: !*this.

🔗

function(const function& f);

Postconditions: !*this if !f; otherwise, *this targets a copy of f.target().

Throws: shall not throw exceptions 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.

[ Note

Implementations are encouraged to 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.

— end note

]

🔗

function(function&& f);

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.

Throws: shall not throw exceptions 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 or move constructor of the stored callable object.

[ Note

— end note

]

🔗

template<class F> function(F f);

Requires: F shall be CopyConstructible.

Remarks: This constructor template shall not participate in overload resolution unless F is Lvalue-Callable ([func.wrap.func]) for argument types ArgTypes... and return type R.

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

(9.1)
f is a null function pointer value.
(9.2)
f is a null member pointer value.
(9.3)
F is an instance of the function class template, and !f.

Otherwise, *this targets a copy of f initialized with std::move(f).

[ Note

Implementations are encouraged to avoid the use of dynamically allocated memory for small callable objects, for example, where f is an object holding only a pointer or reference to an object and a member function pointer.

— end note

]

Throws: shall not throw exceptions when f is a function pointer or a reference_wrapper<T> for some T.

Otherwise, may throw bad_alloc or any exception thrown by F's copy or move constructor.

🔗

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

Remarks: This deduction guide participates in overload resolution only if &F::operator() is well-formed when treated as an unevaluated operand.

In that case, if decltype(&F::operator()) is of the form R(G::*)(A...) cv &

_{o p t}

noexcept

_{o p t}

for a class type G, then the deduced type is function<R(A...)>.

[ Example

void f() {
  int i{5};
  function g = [&](double) { return i; }; // deduces function<int(double)>
}

— end example

]

🔗

function& operator=(const function& f);

Effects: As if by function(f).swap(*this);

Returns: *this.

🔗

function& operator=(function&& f);

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

Returns: *this.

🔗

function& operator=(nullptr_t) noexcept;

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

Postconditions: !(*this).

Returns: *this.

🔗

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

Effects: As if by: function(std::forward<F>(f)).swap(*this);

Returns: *this.

Remarks: This assignment operator shall not participate in overload resolution unless decay_t<F> is Lvalue-Callable ([func.wrap.func]) for argument types ArgTypes... and return type R.

🔗

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

Effects: As if by: function(f).swap(*this);

Returns: *this.

🔗

~function();

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