20 General utilities library [utilities]

20.14 Function objects [function.objects]

20.14.17 Polymorphic function wrappers [func.wrap]

20.14.17.3 Class template function [func.wrap.func]

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

🔗
function() noexcept;
1
#
Postconditions: !*this.
🔗
function(nullptr_t) noexcept;
2
#
Postconditions: !*this.
🔗
function(const function& f);
3
#
Postconditions: !*this if !f; otherwise, *this targets a copy of f.target().
4
#
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.
5
#
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;
6
#
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.
7
#
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.
🔗
template<class F> function(F f);
8
#
Constraints: F is Lvalue-Callable ([func.wrap.func]) for argument types ArgTypes... and return type R.
9
#
Preconditions: F meets the Cpp17CopyConstructible requirements.
10
#
Postconditions: !*this if any of the following hold:
  • (10.1)
    f is a null function pointer value.
  • (10.2)
    f is a null member pointer value.
  • (10.3)
    F is an instance of the function class template, and !f.
11
#
Otherwise, *this targets a copy of f initialized with std​::​move(f).
12
#
Throws: Nothing if f is a specialization of reference_­wrapper or a function pointer.
Otherwise, may throw bad_­alloc or any exception thrown by F's copy or move constructor.
13
#
Recommended practice: Implementations should 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.
🔗
template<class F> function(F) -> function<see below>;
14
#
Constraints: &F​::​operator() is well-formed when treated as an unevaluated operand and decltype(​&F​::​operator()) is of the form R(G​::​*)(A...) cv & noexcept for a class type G.
15
#
Remarks: The deduced type is function<R(A...)>.
16
#
[Example 1: void f() { int i{5}; function g = [&](double) { return i; }; // deduces function<int(double)> } — end example]
🔗
function& operator=(const function& f);
17
#
Effects: As if by function(f).swap(*this);
18
#
Returns: *this.
🔗
function& operator=(function&& f);
19
#
Effects: Replaces the target of *this with the target of f.
20
#
Returns: *this.
🔗
function& operator=(nullptr_t) noexcept;
21
#
Effects: If *this != nullptr, destroys the target of this.
22
#
Postconditions: !(*this).
23
#
Returns: *this.
🔗
template<class F> function& operator=(F&& f);
24
#
Constraints: decay_­t<F> is Lvalue-Callable ([func.wrap.func]) for argument types ArgTypes... and return type R.
25
#
Effects: As if by: function(std​::​forward<F>(f)).swap(*this);
26
#
Returns: *this.
🔗
template<class F> function& operator=(reference_wrapper<F> f) noexcept;
27
#
Effects: As if by: function(f).swap(*this);
28
#
Returns: *this.
🔗
~function();
29
#
Effects: If *this != nullptr, destroys the target of this.