22 General utilities library [utilities]

22.10 Function objects [function.objects]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.6 Non-owning wrapper [func.wrap.ref]

22.10.17.6.3 Constructors and assignment operators [func.wrap.ref.ctor]

🔗
template<class... T> static constexpr bool is-invocable-using = see below;
1
#
If noex is true, is-invocable-using<T...> is equal to: is_nothrow_invocable_r_v<R, T..., ArgTypes...>
Otherwise, is-invocable-using<T...> is equal to: is_invocable_r_v<R, T..., ArgTypes...>
🔗
template<class F> static constexpr bool is-convertible-from-specialization = see below;
2
#
If F denotes a specialization function_ref<R(Args...) cv2 noexcept(noex2)> for some placeholders cv2 and noex2, is-convertible-from-specialization<F> is equal to: is_convertible_v<R(&)(Args...) noexcept(noex2), R(&)(Args...) noexcept(noex)> && is_convertible_v<int cv&, int cv2&>.
Otherwise, is-convertible-from-specialization<F> is false.
🔗
template<class F> function_ref(F* f) noexcept;
3
#
Constraints:
  • (3.1)
    is_function_v<F> is true, and
  • (3.2)
    is-invocable-using<F> is true.
4
#
Preconditions: f is not a null pointer.
5
#
Effects: Initializes bound-entity with f, and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args...) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f, call-args...).
🔗
template<class F> constexpr function_ref(F&& f) noexcept;
6
#
Let T be remove_reference_t<F>.
7
#
Constraints:
  • (7.1)
    remove_cvref_t<F> is not the same type as function_ref,
  • (7.2)
    is_member_pointer_v<T> is false, and
  • (7.3)
    is-invocable-using<cv T&> is true.
8
#
Effects: If is-convertible-from-specialization<remove_cv_t<T>> is false, initializes bound-entity with addressof(f), and thunk-ptr with the address of a function thunk such that thunk(bound-​entity, call-args...) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(static_cast<cv T&>(f), call-args...).
Otherwise, initializes bound-entity with the value of f.bound-entity and thunk-​ptr with the value of f.thunk-ptr.
9
#
Remarks: If remove_cvref_t<F> is a specialization of function_ref, an implementation may initialize bound-entity with the value of f.bound-entity and thunk-ptr with the value of f.thunk-ptr.
[Example 1: void f1(std::string); void f2(std::string); function_ref<void(std::string)> r1(&f1); function_ref<void(std::string&&)> r2(r1); r2(""); // f1 is invoked r1 = &f2; r2(""); // it is unspecified if f1 or f2 is invoked — end example]
🔗
template<auto c, class F> constexpr function_ref(constant_wrapper<c, F> f) noexcept;
10
#
Constraints: is-invocable-using<const F&> is true.
11
#
Mandates:
  • (11.1)
    If is_pointer_v<F> || is_member_pointer_v<F> is true, then f.value != nullptr is true, and
  • (11.2)
    if ArgTypes is not an empty pack and all types in remove_cvref_t<ArgTypes>... satisfy constexpr-param then constant_wrapper<INVOKE(f.value, remove_cvref_t<ArgTypes>​::​
    value...)>     is not a valid type.
12
#
Effects: Initializes bound-entity with a pointer to an unspecified object or null pointer value, and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args...) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f, call-args...).
🔗
template<auto c, class F, class U> constexpr function_ref(constant_wrapper<c, F> f, U&& obj) noexcept;
13
#
Let T be remove_reference_t<U>.
14
#
Constraints:
  • (14.1)
    is_rvalue_reference_v<U&&> is false, and
  • (14.2)
    is-invocable-using<const F&, cv T&> is true.
15
#
Mandates: If is_pointer_v<F> || is_member_pointer_v<F> is true, then f.value != nullptr is true.
16
#
Effects: Initializes bound-entity with addressof(obj), and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args...) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f.value, static_cast<cv T&>(obj), call-args...).
🔗
template<auto c, class F> constexpr function_ref(constant_wrapper<c, F> f, cv T* obj) noexcept;
17
#
Constraints: is-invocable-using<const F&, cv T*> is true.
18
#
Mandates: If is_pointer_v<F> || is_member_pointer_v<F> is true, then f.value != nullptr is true.
19
#
Preconditions: If is_member_pointer_v<F> is true, obj is not a null pointer.
20
#
Effects: Initializes bound-entity with obj, and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args...) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f.value, obj, call-args...).
🔗
template<class T> function_ref& operator=(T) = delete;
21
#
Constraints:
  • (21.1)
    is-convertible-from-specialization<T> is false,
  • (21.2)
    is_pointer_v<T> is false, and
  • (21.3)
    T is not a specialization of constant_wrapper.