20 General utilities library [utilities]

20.14 Function objects [function.objects]

20.14.3 Requirements [func.require]

Define INVOKE(f, t

_{1}

, t

_{2}

, …, t

_{N}

) as follows:

(1.1)
(t $_{1}$ .*f)(t $_{2}$ , …, t $_{N}$ ) when f is a pointer to a member function of a class T and is_base_of_v<T, remove_reference_t<decltype(t $_{1}$ )>> is true;
(1.2)
(t $_{1}$ .get().*f)(t $_{2}$ , …, t $_{N}$ ) when f is a pointer to a member function of a class T and remove_cvref_t<decltype(t $_{1}$ )> is a specialization of reference_wrapper;
(1.3)
((*t $_{1}$ ).*f)(t $_{2}$ , …, t $_{N}$ ) when f is a pointer to a member function of a class T and t $_{1}$ does not satisfy the previous two items;
(1.4)
t $_{1}$ .*f when N == 1 and f is a pointer to data member of a class T and is_base_of_v<T, remove_reference_t<decltype(t $_{1}$ )>> is true;
(1.5)
t $_{1}$ .get().*f when N == 1 and f is a pointer to data member of a class T and remove_cvref_t<decltype(t $_{1}$ )> is a specialization of reference_wrapper;
(1.6)
(*t $_{1}$ ).*f when N == 1 and f is a pointer to data member of a class T and t $_{1}$ does not satisfy the previous two items;
(1.7)
f(t $_{1}$ , t $_{2}$ , …, t $_{N}$ ) in all other cases.

Define INVOKE<R>(f, t

_{1}

, t

_{2}

, …, t

_{N}

) as static_cast<void>(INVOKE(f, t

_{1}

, t

_{2}

, …, t

_{N}

)) if R is cv void, otherwise INVOKE(f, t

_{1}

, t

_{2}

, …, t

_{N}

) implicitly converted to R.

Every call wrapper ([func.def]) meets the Cpp17MoveConstructible and Cpp17Destructible requirements.

An argument forwarding call wrapper is a call wrapper that can be called with an arbitrary argument list and delivers the arguments to the wrapped callable object as references.

This forwarding step delivers rvalue arguments as rvalue references and lvalue arguments as lvalue references.

[ Note

In a typical implementation, argument forwarding call wrappers have an overloaded function call operator of the form

template<class... UnBoundArgs>
  constexpr R operator()(UnBoundArgs&&... unbound_args) cv-qual;

— end note

]

A perfect forwarding call wrapper is an argument forwarding call wrapper that forwards its state entities to the underlying call expression.

This forwarding step delivers a state entity of type T as cv T& when the call is performed on an lvalue of the call wrapper type and as cv T&& otherwise, where cv represents the cv-qualifiers of the call wrapper and where cv shall be neither volatile nor const volatile.

A call pattern defines the semantics of invoking a perfect forwarding call wrapper.

A postfix call performed on a perfect forwarding call wrapper is expression-equivalent ([defns.expression-equivalent]) to an expression e determined from its call pattern cp by replacing all occurrences of the arguments of the call wrapper and its state entities with references as described in the corresponding forwarding steps.

A simple call wrapper is a perfect forwarding call wrapper that meets the Cpp17CopyConstructible and Cpp17CopyAssignable requirements and whose copy constructor, move constructor, and assignment operators are constexpr functions that do not throw exceptions.

The copy/move constructor of an argument forwarding call wrapper has the same apparent semantics as if memberwise copy/move of its state entities were performed ([class.copy.ctor]).

[ Note

This implies that each of the copy/move constructors has the same exception-specification as the corresponding implicit definition and is declared as constexpr if the corresponding implicit definition would be considered to be constexpr.

— end note

]

Argument forwarding call wrappers returned by a given standard library function template have the same type if the types of their corresponding state entities are the same.