22 General utilities library [utilities]

22.10 Function objects [function.objects]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.5 Copyable wrapper [func.wrap.copy]

22.10.17.5.3 Constructors, assignments, and destructors [func.wrap.copy.ctor]

🔗
template<class VT> static constexpr bool is-callable-from = see below;
1
#
If noex is true, is-callable-from<VT> is equal to: is_nothrow_invocable_r_v<R, VT cv ref, ArgTypes...> && is_nothrow_invocable_r_v<R, VT inv-quals, ArgTypes...>
Otherwise, is-callable-from<VT> is equal to: is_invocable_r_v<R, VT cv ref, ArgTypes...> && is_invocable_r_v<R, VT inv-quals, ArgTypes...>
🔗
copyable_function() noexcept; copyable_function(nullptr_t) noexcept;
2
#
Postconditions: *this has no target object.
🔗
copyable_function(const copyable_function& f);
3
#
Postconditions: *this has no target object if f had no target object.
Otherwise, the target object of *this is a copy of the target object of f.
4
#
Throws: Any exception thrown by the initialization of the target object.
May throw bad_alloc.
🔗
copyable_function(copyable_function&& f) noexcept;
5
#
Postconditions: The target object of *this is the target object f had before construction, and f is in a valid state with an unspecified value.
🔗
template<class F> copyable_function(F&& f);
6
#
Let VT be decay_t<F>.
7
#
Constraints:
  • (7.1)
    remove_cvref_t<F> is not the same type as copyable_function, and
  • (7.2)
    remove_cvref_t<F> is not a specialization of in_place_type_t, and
  • (7.3)
    is-callable-from<VT> is true.
8
#
Mandates:
  • (8.1)
    is_constructible_v<VT, F> is true, and
  • (8.2)
    is_copy_constructible_v<VT> is true.
9
#
Preconditions: VT meets the Cpp17Destructible and Cpp17CopyConstructible requirements.
10
#
Postconditions: *this has no target object if any of the following hold:
  • (10.1)
    f is a null function pointer value, or
  • (10.2)
    f is a null member pointer value, or
  • (10.3)
    remove_cvref_t<F> is a specialization of the copyable_function class template, and f has no target object.
Otherwise, *this has a target object of type VT direct-non-list-initialized with std​::​forward<F>(f).
11
#
Throws: Any exception thrown by the initialization of the target object.
May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.
🔗
template<class T, class... Args> explicit copyable_function(in_place_type_t<T>, Args&&... args);
12
#
Let VT be decay_t<T>.
13
#
Constraints:
  • (13.1)
    is_constructible_v<VT, Args...> is true, and
  • (13.2)
    is-callable-from<VT> is true.
14
#
Mandates:
  • (14.1)
    VT is the same type as T, and
  • (14.2)
    is_copy_constructible_v<VT> is true.
15
#
Preconditions: VT meets the Cpp17Destructible and Cpp17CopyConstructible requirements.
16
#
Postconditions: *this has a target object of type VT direct-non-list-initialized with std​::​forward<Args>​(args)....
17
#
Throws: Any exception thrown by the initialization of the target object.
May throw bad_alloc unless VT is a pointer or a specialization of reference_wrapper.
🔗
template<class T, class U, class... Args> explicit copyable_function(in_place_type_t<T>, initializer_list<U> ilist, Args&&... args);
18
#
Let VT be decay_t<T>.
19
#
Constraints:
  • (19.1)
    is_constructible_v<VT, initializer_list<U>&, Args...> is true, and
  • (19.2)
    is-callable-from<VT> is true.
20
#
Mandates:
  • (20.1)
    VT is the same type as T, and
  • (20.2)
    is_copy_constructible_v<VT> is true.
21
#
Preconditions: VT meets the Cpp17Destructible and Cpp17CopyConstructible requirements.
22
#
Postconditions: *this has a target object of type VT direct-non-list-initialized with ilist, std​::​forward<Args>(args)....
23
#
Throws: Any exception thrown by the initialization of the target object.
May throw bad_alloc unless VT is a pointer or a specialization of reference_wrapper.
🔗
copyable_function& operator=(const copyable_function& f);
24
#
Effects: Equivalent to: copyable_function(f).swap(*this);
25
#
Returns: *this.
🔗
copyable_function& operator=(copyable_function&& f);
26
#
Effects: Equivalent to: copyable_function(std​::​move(f)).swap(*this);
27
#
Returns: *this.
🔗
copyable_function& operator=(nullptr_t) noexcept;
28
#
Effects: Destroys the target object of *this, if any.
29
#
Returns: *this.
🔗
template<class F> copyable_function& operator=(F&& f);
30
#
Effects: Equivalent to: copyable_function(std​::​forward<F>(f)).swap(*this);
31
#
Returns: *this.
🔗
~copyable_function();
32
#
Effects: Destroys the target object of *this, if any.