[function.objects]

185)185)

Such a type is a function pointer or a class type which has a member operator() or a class type which has a conversion to a pointer to function.

22.10.2 Header <functional> synopsis [functional.syn]

🔗

#include <initializer_list> / see [initializer.list.syn] #include <typeinfo> / see [typeinfo.syn] namespace std { / [func.invoke], invoke template<class F, class. Args> constexpr invoke_result_t<F, Args..> invoke(F&& f, Args&&. args) / freestanding noexcept(is_nothrow_invocable_v<F, Args..>); template<class R, class F, class. Args> constexpr R invoke_r(F&& f, Args&&. args) / freestanding noexcept(is_nothrow_invocable_r_v<R, F, Args..>); / [refwrap], reference_wrapper template<class T> class reference_wrapper; / freestanding template<class T> constexpr reference_wrapper<T> ref(T&) noexcept; / freestanding template<class T> constexpr reference_wrapper<const T> cref(const T&) noexcept; / freestanding template<class T> void ref(const T&&) = delete; / freestanding template<class T> void cref(const T&&) = delete; / freestanding template<class T> constexpr reference_wrapper<T> ref(reference_wrapper<T>) noexcept; / freestanding template<class T> constexpr reference_wrapper<const T> cref(reference_wrapper<T>) noexcept; / freestanding / [refwrap.common.ref], common_reference related specializations template<class R, class T, template<class> class RQual, template<class> class TQual> requires see below struct basic_common_reference<R, T, RQual, TQual>; template<class T, class R, template<class> class TQual, template<class> class RQual> requires see below struct basic_common_reference<T, R, TQual, RQual>; / [arithmetic.operations], arithmetic operations template<class T = void> struct plus; / freestanding template<class T = void> struct minus; / freestanding template<class T = void> struct multiplies; / freestanding template<class T = void> struct divides; / freestanding template<class T = void> struct modulus; / freestanding template<class T = void> struct negate; / freestanding template<> struct plus<void>; / freestanding template<> struct minus<void>; / freestanding template<> struct multiplies<void>; / freestanding template<> struct divides<void>; / freestanding template<> struct modulus<void>; / freestanding template<> struct negate<void>; / freestanding / [comparisons], comparisons template<class T = void> struct equal_to; / freestanding template<class T = void> struct not_equal_to; / freestanding template<class T = void> struct greater; / freestanding template<class T = void> struct less; / freestanding template<class T = void> struct greater_equal; / freestanding template<class T = void> struct less_equal; / freestanding template<> struct equal_to<void>; / freestanding template<> struct not_equal_to<void>; / freestanding template<> struct greater<void>; / freestanding template<> struct less<void>; / freestanding template<> struct greater_equal<void>; / freestanding template<> struct less_equal<void>; / freestanding / [comparisons.three.way], class compare_three_way struct compare_three_way; / freestanding / [logical.operations], logical operations template<class T = void> struct logical_and; / freestanding template<class T = void> struct logical_or; / freestanding template<class T = void> struct logical_not; / freestanding template<> struct logical_and<void>; / freestanding template<> struct logical_or<void>; / freestanding template<> struct logical_not<void>; / freestanding / [bitwise.operations], bitwise operations template<class T = void> struct bit_and; / freestanding template<class T = void> struct bit_or; / freestanding template<class T = void> struct bit_xor; / freestanding template<class T = void> struct bit_not; / freestanding template<> struct bit_and<void>; / freestanding template<> struct bit_or<void>; / freestanding template<> struct bit_xor<void>; / freestanding template<> struct bit_not<void>; / freestanding / [func.identity], identity struct identity; / freestanding / [func.not.fn], function template not_fn template<class F> constexpr unspecified not_fn(F&& f); / freestanding template<auto f> constexpr unspecified not_fn() noexcept; / freestanding / [func.bind.partial], function templates bind_front and bind_back template<class F, class. Args> constexpr unspecified bind_front(F&&, Args&&.); / freestanding template<auto f, class. Args> constexpr unspecified bind_front(Args&&.); / freestanding template<class F, class. Args> constexpr unspecified bind_back(F&&, Args&&.); / freestanding template<auto f, class. Args> constexpr unspecified bind_back(Args&&.); / freestanding / [func.bind], bind template<class T> struct is_bind_expression; / freestanding template<class T> constexpr bool is_bind_expression_v = / freestanding is_bind_expression<T>::value; template<class T> struct is_placeholder; / freestanding template<class T> constexpr int is_placeholder_v = / freestanding is_placeholder<T>::value; template<class F, class. BoundArgs> constexpr unspecified bind(F&&, BoundArgs&&.); / freestanding template<class R, class F, class. BoundArgs> constexpr unspecified bind(F&&, BoundArgs&&.); / freestanding namespace placeholders { / M is the implementation-defined number of placeholders see below _1; / freestanding see below _2; / freestanding ⋮ see below _M; / freestanding } / [func.memfn], member function adaptors template<class R, class T> constexpr unspecified mem_fn(R T::*) noexcept; / freestanding / [func.wrap], polymorphic function wrappers / [func.wrap.badcall], class bad_function_call class bad_function_call; / [func.wrap.func], class template function template<class> class function; / not defined template<class R, class. ArgTypes> class function<R(ArgTypes..)>; / [func.wrap.func.alg], function specialized algorithms template<class R, class. ArgTypes> void swap(function<R(ArgTypes..)>&, function<R(ArgTypes..)>&) noexcept; / [func.wrap.func.nullptr], function null pointer comparison operator functions template<class R, class. ArgTypes> bool operator=(const function<R(ArgTypes..)>&, nullptr_t) noexcept; / [func.wrap.move], move-only wrapper template<class. S> class move_only_function; / not defined template<class R, class. ArgTypes> class move_only_function<R(ArgTypes..) cv ref noexcept(noex)>; / see below / [func.wrap.copy], copyable wrapper template<class. S> class copyable_function; / not defined template<class R, class. ArgTypes> class copyable_function<R(ArgTypes..) cv ref noexcept(noex)>; / see below / [func.wrap.ref], non-owning wrapper template<class. S> class function_ref; / freestanding, not defined template<class R, class. ArgTypes> class function_ref<R(ArgTypes..) cv noexcept(noex)>; / freestanding, see below / [func.search], searchers template<class ForwardIterator1, class BinaryPredicate = equal_to<> class default_searcher; / freestanding template<class RandomAccessIterator, class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, class BinaryPredicate = equal_to<> class boyer_moore_searcher; template<class RandomAccessIterator, class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, class BinaryPredicate = equal_to<> class boyer_moore_horspool_searcher; / [unord.hash], class template hash template<class T> struct hash; / freestanding namespace ranges { / [range.cmp], concept-constrained comparisons struct equal_to; / freestanding struct not_equal_to; / freestanding struct greater; / freestanding struct less; / freestanding struct greater_equal; / freestanding struct less_equal; / freestanding } template<class Fn, class. Args> concept callable = / exposition only requires (Fn&& fn, Args&&. args) { std::forward<Fn>(fn)(std::forward<Args>(args).); }; template<class Fn, class. Args> concept nothrow-callable = / exposition only callable<Fn, Args..> && requires (Fn&& fn, Args&&. args) { { std::forward<Fn>(fn)(std::forward<Args>(args).) } noexcept; }; template<class Fn, class. Args> using call-result-t = decltype(declval<Fn>()(declval<Args>().); / exposition only template<const auto& T> using decayed-typeof = decltype(auto(T)); / exposition only }

[Example 1:

If a C++ program wants to have a by-element addition of two vectors a and b containing double and put the result into a, it can do: transform(a.begin(), a.end(), b.begin(), a.begin(), plus<double>();

— end example]

[Example 2:

To negate every element of a:

transform(a.begin(), a.end(), a.begin(), negate<double>(); — end example]

22.10.3 Definitions [func.def]

A call signature is the name of a return type followed by a parenthesized comma-separated list of zero or more argument types.

A call wrapper type is a type that holds a callable object and supports a call operation that forwards to that object.

A call wrapper type may additionally hold a sequence of objects and references that may be passed as arguments to the target object.

These entities are collectively referred to as bound argument entities.

The target object and bound argument entities of the call wrapper are collectively referred to as state entities.

22.10.4 Requirements [func.require]

Define INVOKE(f, t

Define INVOKE<R>(f, t

{1, t {2, \dots, t {N) as static_cast < void > (INVOKE (f, t {1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}}_{1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}}}_{N)}}_{2, \dots, t {N) as static_cast < void > (INVOKE (f, t {1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}}_{1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t_{,, t}}}_{N)}}}}_{N)}}}_{1, t {2, \dots, t {N) as static_cast < void > (INVOKE (f, t {1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}}_{1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t_{,, t}}}_{N)}}}}_{N)}}_{2, \dots, t {N) as static_cast < void > (INVOKE (f, t {1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t_{,, t}}}_{N)}}}_{1, t {2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t}_{1, t_{,, t}}}_{N)}}_{2, \dots, t {N) if R is cv void, otherwise INVOKE (f, t {1, t_{,, t}}_{1, t {,, t}_{, \dots, t}}}_{N)}}}}_{N)}}}

If reference_converts_from_temporary_v<R, decltype(INVOKE(f, t

{1, t {2, \dots, t {N) > is true, INVOKE < R > (f, t {1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}_{1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}}_{N) >}}_{2, \dots, t {N) > is true, INVOKE < R > (f, t {1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}_{1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}}_{N) >}}}_{1, t {2, \dots, t {N) > is true, INVOKE < R > (f, t {1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}_{1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}}_{N) >}}_{2, \dots, t {N) > is true, INVOKE < R > (f, t {1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}_{1, t {2, \dots, t {N) is ill-formed .}_{N)}}_{2, \dots, t {N) is ill-formed .}_{N)}}}}_{N) >}}}

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 target object as references.

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

[Note 1:

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 2:

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.

22.10.5 invoke functions [func.invoke]

🔗

template<class F, class. Args>
  constexpr invoke_result_t<F, Args..> invoke(F&& f, Args&&. args)
    noexcept(is_nothrow_invocable_v<F, Args..>);

Returns: INVOKE(std::forward<F>(f), std::forward<Args>(args).) ([func.require]).

🔗

template<class R, class F, class. Args>
  constexpr R invoke_r(F&& f, Args&&. args)
    noexcept(is_nothrow_invocable_r_v<R, F, Args..>);

Returns: INVOKE<R>(std::forward<F>(f), std::forward<Args>(args).) ([func.require]).

22.10.6 Class template reference_wrapper [refwrap]

22.10.6.1 General [refwrap.general]

🔗

namespace std { template<class T> class reference_wrapper { public: / types using type = T; / [refwrap.const], constructors template<class U> constexpr reference_wrapper(U&&) noexcept(see below); constexpr reference_wrapper(const reference_wrapper& x) noexcept; / [refwrap.assign], assignment constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept; / [refwrap.access], access constexpr operator T& () const noexcept; constexpr T& get() const noexcept; / [refwrap.invoke], invocation template<class. ArgTypes> constexpr invoke_result_t<T&, ArgTypes..> operator()(ArgTypes&&.) const noexcept(is_nothrow_invocable_v<T&, ArgTypes..>); / [refwrap.comparisons], comparisons friend constexpr bool operator=(reference_wrapper, reference_wrapper); friend constexpr bool operator=(reference_wrapper, const T&); friend constexpr bool operator=(reference_wrapper, reference_wrapper<const T>); friend constexpr auto operator<=>(reference_wrapper, reference_wrapper); friend constexpr auto operator<=>(reference_wrapper, const T&); friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>); }; template<class T> reference_wrapper(T&) -> reference_wrapper<T>; }

reference_wrapper<T> is a Cpp17CopyConstructible and Cpp17CopyAssignable wrapper around a reference to an object or function of type T.

reference_wrapper<T> is a trivially copyable type ([basic.types.general]).

The template parameter T of reference_wrapper may be an incomplete type.

[Note 1:

Using the comparison operators described in [refwrap.comparisons] with T being an incomplete type can lead to an ill-formed program with no diagnostic required ([temp.point], [temp.constr.atomic]).

— end note]

22.10.6.2 Constructors [refwrap.const]

🔗

template<class U>
  constexpr reference_wrapper(U&& u) noexcept(see below);

Let FUN denote the exposition-only functions void FUN(T&) noexcept; void FUN(T&&) = delete;

Constraints: The expression FUN(declval() is well-formed and is_same_v<remove_cvref_t, reference_wrapper> is false.

Effects: Creates a variable r as if by T& r = std::forward(u), then constructs a reference_wrapper object that stores a reference to r.

Remarks: The exception specification is equivalent to noexcept(FUN(declval().

🔗

constexpr reference_wrapper(const reference_wrapper& x) noexcept;

Effects: Constructs a reference_wrapper object that stores a reference to x.get().

22.10.6.3 Assignment [refwrap.assign]

🔗

constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept;

Postconditions: *this stores a reference to x.get().

22.10.6.4 Access [refwrap.access]

🔗

constexpr operator T& () const noexcept;

Returns: The stored reference.

🔗

constexpr T& get() const noexcept;

Returns: The stored reference.

22.10.6.5 Invocation [refwrap.invoke]

🔗

template<class. ArgTypes>
  constexpr invoke_result_t<T&, ArgTypes..>
    operator()(ArgTypes&&. args) const noexcept(is_nothrow_invocable_v<T&, ArgTypes..>);

Returns: INVOKE(get(), std::forward<ArgTypes>(args).) ([func.require]).

22.10.6.6 Comparisons [refwrap.comparisons]

🔗

friend constexpr bool operator=(reference_wrapper x, reference_wrapper y);

Constraints: The expression x.get() == y.get() is well-formed and its result is convertible to bool.

Returns: x.get() == y.get().

🔗

friend constexpr bool operator=(reference_wrapper x, const T& y);

Constraints: The expression x.get() == y is well-formed and its result is convertible to bool.

Returns: x.get() == y.

🔗

friend constexpr bool operator=(reference_wrapper x, reference_wrapper<const T> y);

Constraints: is_const_v<T> is false and the expression x.get() == y.get() is well-formed and its result is convertible to bool.

Returns: x.get() == y.get().

🔗

friend constexpr auto operator<=>(reference_wrapper x, reference_wrapper y);

Constraints: The expression synth-three-way(x.get(), y.get() is well-formed.

Returns: synth-three-way(x.get(), y.get().

🔗

friend constexpr auto operator<=>(reference_wrapper x, const T& y);

Constraints: The expression synth-three-way(x.get(), y) is well-formed.

Returns: synth-three-way(x.get(), y).

🔗

friend constexpr auto operator<=>(reference_wrapper x, reference_wrapper<const T> y);

Constraints: is_const_v<T> is false.

The expression synth-three-way(x.get(), y.get() is well-formed.

The template parameter T of the following ref and cref function templates may be an incomplete type.

🔗

template<class T> constexpr reference_wrapper<T> ref(T& t) noexcept;

Returns: reference_wrapper<T>(t).

🔗

template<class T> constexpr reference_wrapper<T> ref(reference_wrapper<T> t) noexcept;

Returns: t.

🔗

template<class T> constexpr reference_wrapper<const T> cref(const T& t) noexcept;

Returns: reference_wrapper<const T>(t).

🔗

template<class T> constexpr reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;

Returns: t.

22.10.6.8 common_reference related specializations [refwrap.common.ref]

🔗

namespace std { template<class T> constexpr bool is-ref-wrapper = false; / exposition only template<class T> constexpr bool is-ref-wrapper<reference_wrapper<T>> = true; template<class R, class T, class RQ, class TQ> concept ref-wrap-common-reference-exists-with = / exposition only is-ref-wrapper<R> && requires { typename common_reference_t<typename R::type&, TQ>; } && convertible_to<RQ, common_reference_t<typename R::type&, TQ>>; template<class R, class T, template<class> class RQual, template<class> class TQual> requires (ref-wrap-common-reference-exists-with<R, T, RQual<R>, TQual<T>> && !ref-wrap-common-reference-exists-with<T, R, TQual<T>, RQual<R>>) struct basic_common_reference<R, T, RQual, TQual> { using type = common_reference_t<typename R::type&, TQual<T>>; }; template<class T, class R, template<class> class TQual, template<class> class RQual> requires (ref-wrap-common-reference-exists-with<R, T, RQual<R>, TQual<T>> && !ref-wrap-common-reference-exists-with<T, R, TQual<T>, RQual<R>>) struct basic_common_reference<T, R, TQual, RQual> { using type = common_reference_t<typename R::type&, TQual<T>>; }; }

22.10.7 Arithmetic operations [arithmetic.operations]

22.10.7.1 General [arithmetic.operations.general]

The library provides basic function object classes for all of the arithmetic operators in the language ([expr.mul], [expr.add]).

22.10.7.2 Class template plus [arithmetic.operations.plus]

🔗

template<class T = void> struct plus {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x + y.

🔗

template<> struct plus<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) + std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) + std::forward<U>(u));

Returns: std::forward<T>(t) + std::forward(u).

22.10.7.3 Class template minus [arithmetic.operations.minus]

🔗

template<class T = void> struct minus {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x - y.

🔗

template<> struct minus<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) - std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) - std::forward<U>(u));

Returns: std::forward<T>(t) - std::forward(u).

22.10.7.4 Class template multiplies [arithmetic.operations.multiplies]

🔗

template<class T = void> struct multiplies {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x * y.

🔗

template<> struct multiplies<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) * std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) * std::forward<U>(u));

Returns: std::forward<T>(t) * std::forward(u).

22.10.7.5 Class template divides [arithmetic.operations.divides]

🔗

template<class T = void> struct divides {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x / y.

🔗

template<> struct divides<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) / std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) / std::forward<U>(u));

Returns: std::forward<T>(t) / std::forward(u).

22.10.7.6 Class template modulus [arithmetic.operations.modulus]

🔗

template<class T = void> struct modulus {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x % y.

🔗

template<> struct modulus<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) % std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) % std::forward<U>(u));

Returns: std::forward<T>(t) % std::forward(u).

22.10.7.7 Class template negate [arithmetic.operations.negate]

🔗

template<class T = void> struct negate {
  constexpr T operator()(const T& x) const;
};

🔗

constexpr T operator()(const T& x) const;

Returns: -x.

🔗

template<> struct negate<void> {
  template<class T> constexpr auto operator()(T&& t) const
    -> decltype(-std::forward<T>(t));

  using is_transparent = unspecified;
};

🔗

template<class T> constexpr auto operator()(T&& t) const
    -> decltype(-std::forward<T>(t));

The library provides basic function object classes for all of the comparison operators in the language ([expr.rel], [expr.eq]).

For templates less, greater, less_equal, and greater_equal, the specializations for any pointer type yield a result consistent with the implementation-defined strict total order over pointers ([defns.order.ptr]).

[Note 1:

If a ()(a, b), (a > b) == greater()(a, b), and so forth.

— end note]

For template specializations less<void>, greater<void>, less_equal<void>, and greater_equal<void>, if the call operator calls a built-in operator comparing pointers, the call operator yields a result consistent with the implementation-defined strict total order over pointers.

22.10.8.2 Class template equal_to [comparisons.equal.to]

🔗

template<class T = void> struct equal_to {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x == y.

🔗

template<> struct equal_to<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) == std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) == std::forward<U>(u));

Returns: std::forward<T>(t) == std::forward(u).

22.10.8.3 Class template not_equal_to [comparisons.not.equal.to]

🔗

template<class T = void> struct not_equal_to {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x != y.

🔗

template<> struct not_equal_to<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) != std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) != std::forward<U>(u));

Returns: std::forward<T>(t) != std::forward(u).

22.10.8.4 Class template greater [comparisons.greater]

🔗

template<class T = void> struct greater {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x > y.

🔗

template<> struct greater<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) > std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) > std::forward<U>(u));

Returns: std::forward<T>(t) > std::forward(u).

22.10.8.5 Class template less [comparisons.less]

🔗

template<class T = void> struct less {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x < y.

🔗

template<> struct less<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) < std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) < std::forward<U>(u));

Returns: std::forward<T>(t) < std::forward(u).

22.10.8.6 Class template greater_equal [comparisons.greater.equal]

🔗

template<class T = void> struct greater_equal {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x >= y.

🔗

template<> struct greater_equal<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) >= std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) >= std::forward<U>(u));

Returns: std::forward<T>(t) >= std::forward(u).

22.10.8.7 Class template less_equal [comparisons.less.equal]

🔗

template<class T = void> struct less_equal {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x <= y.

🔗

template<> struct less_equal<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) <= std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) <= std::forward<U>(u));

Returns: std::forward<T>(t) <= std::forward(u).

22.10.8.8 Class compare_three_way [comparisons.three.way]

🔗

namespace std { struct compare_three_way { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const; using is_transparent = unspecified; }; }

🔗

template<class T, class U>
  constexpr auto operator()(T&& t, U&& u) const;

Preconditions: If the expression std::forward<T>(t) <=> std::forward(u) results in a call to a built-in operator <=> comparing pointers of type P, the conversion sequences from both T and U to P are equality-preserving ([concepts.equality]); otherwise, T and U model three_way_comparable_with .

Effects:

(3.1)
If the expression std::forward<T>(t) <=> std::forward(u) results in a call to a built-in operator <=> comparing pointers of type P, returns strong_ordering::less if (the converted value of) t precedes u in the implementation-defined strict total order over pointers ([defns.order.ptr]), strong_ordering::greater if u precedes t, and otherwise strong_ordering::equal.
(3.2)
Otherwise, equivalent to: return std::forward<T>(t) <=> std::forward(u);

22.10.9 Concept-constrained comparisons [range.cmp]

🔗

struct ranges::equal_to { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const; using is_transparent = unspecified; };

🔗

template<class T, class U>
  constexpr bool operator()(T&& t, U&& u) const;

Preconditions: If the expression std::forward<T>(t) == std::forward(u) results in a call to a built-in operator == comparing pointers of type P, the conversion sequences from both T and U to P are equality-preserving ([concepts.equality]); otherwise, T and U model equality_comparable_with .

Effects:

(3.1)
If the expression std::forward<T>(t) == std::forward(u) results in a call to a built-in operator == comparing pointers: returns false if either (the converted value of) t precedes u or u precedes t in the implementation-defined strict total order over pointers ([defns.order.ptr]) and otherwise true.
(3.2)
Otherwise, equivalent to: return std::forward<T>(t) == std::forward(u);

🔗

struct ranges::not_equal_to { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const; using is_transparent = unspecified; };

🔗

template<class T, class U>
  constexpr bool operator()(T&& t, U&& u) const;

Effects: Equivalent to: return !ranges::equal_to{}(std::forward<T>(t), std::forward(u));

🔗

struct ranges::greater { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const; using is_transparent = unspecified; };

🔗

template<class T, class U>
  constexpr bool operator()(T&& t, U&& u) const;

Effects: Equivalent to: return ranges::less{}(std::forward(u), std::forward<T>(t));

🔗

struct ranges::less { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const; using is_transparent = unspecified; };

🔗

template<class T, class U>
  constexpr bool operator()(T&& t, U&& u) const;

Preconditions: If the expression std::forward<T>(t) < std::forward(u) results in a call to a built-in operator < comparing pointers of type P, the conversion sequences from both T and U to P are equality-preserving ([concepts.equality]); otherwise, T and U model totally_ordered_with .

For any expressions ET and EU such that decltype(ET)) is T and decltype(EU)) is U, exactly one of ranges::less{}(ET, EU), ranges::less{}(EU, ET), or ranges::equal_to{}(ET, EU) is true.

Effects:

(10.1)
If the expression std::forward<T>(t) < std::forward(u) results in a call to a built-in operator < comparing pointers: returns true if (the converted value of) t precedes u in the implementation-defined strict total order over pointers ([defns.order.ptr]) and otherwise false.
(10.2)
Otherwise, equivalent to: return std::forward<T>(t) < std::forward(u);

🔗

struct ranges::greater_equal { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const; using is_transparent = unspecified; };

🔗

template<class T, class U>
  constexpr bool operator()(T&& t, U&& u) const;

Effects: Equivalent to: return !ranges::less{}(std::forward<T>(t), std::forward(u));

🔗

struct ranges::less_equal {
  template<class T, class U>
    constexpr bool operator()(T&& t, U&& u) const;

  using is_transparent = unspecified;
};

🔗

template<class T, class U>
  constexpr bool operator()(T&& t, U&& u) const;

Effects: Equivalent to: return !ranges::less{}(std::forward(u), std::forward<T>(t));

22.10.10 Logical operations [logical.operations]

22.10.10.1 General [logical.operations.general]

The library provides basic function object classes for all of the logical operators in the language ([expr.log.and], [expr.log.or], [expr.unary.op]).

22.10.10.2 Class template logical_and [logical.operations.and]

🔗

template<class T = void> struct logical_and {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x && y.

🔗

template<> struct logical_and<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) && std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) && std::forward<U>(u));

Returns: std::forward<T>(t) && std::forward(u).

22.10.10.3 Class template logical_or [logical.operations.or]

🔗

template<class T = void> struct logical_or {
  constexpr bool operator()(const T& x, const T& y) const;
};

🔗

constexpr bool operator()(const T& x, const T& y) const;

Returns: x || y.

🔗

template<> struct logical_or<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) || std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) || std::forward<U>(u));

Returns: std::forward<T>(t) || std::forward(u).

22.10.10.4 Class template logical_not [logical.operations.not]

🔗

template<class T = void> struct logical_not {
  constexpr bool operator()(const T& x) const;
};

🔗

constexpr bool operator()(const T& x) const;

Returns: !x.

🔗

template<> struct logical_not<void> {
  template<class T> constexpr auto operator()(T&& t) const
    -> decltype(!std::forward<T>(t));

  using is_transparent = unspecified;
};

🔗

template<class T> constexpr auto operator()(T&& t) const
    -> decltype(!std::forward<T>(t));

The library provides basic function object classes for all of the bitwise operators in the language ([expr.bit.and], [expr.or], [expr.xor], [expr.unary.op]).

22.10.11.2 Class template bit_and [bitwise.operations.and]

🔗

template<class T = void> struct bit_and {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x & y.

🔗

template<> struct bit_and<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) & std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) & std::forward<U>(u));

Returns: std::forward<T>(t) & std::forward(u).

22.10.11.3 Class template bit_or [bitwise.operations.or]

🔗

template<class T = void> struct bit_or {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x | y.

🔗

template<> struct bit_or<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) | std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) | std::forward<U>(u));

Returns: std::forward<T>(t) | std::forward(u).

22.10.11.4 Class template bit_xor [bitwise.operations.xor]

🔗

template<class T = void> struct bit_xor {
  constexpr T operator()(const T& x, const T& y) const;
};

🔗

constexpr T operator()(const T& x, const T& y) const;

Returns: x ^ y.

🔗

template<> struct bit_xor<void> {
  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) ^ std::forward<U>(u));

  using is_transparent = unspecified;
};

🔗

template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) ^ std::forward<U>(u));

Returns: std::forward<T>(t) ^ std::forward(u).

22.10.11.5 Class template bit_not [bitwise.operations.not]

🔗

template<class T = void> struct bit_not {
  constexpr T operator()(const T& x) const;
};

🔗

constexpr T operator()(const T& x) const;

Returns: ~x.

🔗

template<> struct bit_not<void> {
  template<class T> constexpr auto operator()(T&& t) const
    -> decltype(~std::forward<T>(t));

  using is_transparent = unspecified;
};

🔗

template<class T> constexpr auto operator()(T&& t) const
    -> decltype(~std::forward<T>(t));

Returns: ~std::forward<T>(t).

22.10.12 Class identity [func.identity]

🔗

struct identity {
  template<class T>
    constexpr T&& operator()(T&& t) const noexcept;

  using is_transparent = unspecified;
};

template<class T>
  constexpr T&& operator()(T&& t) const noexcept;

Effects: Equivalent to: return std::forward<T>(t);

22.10.13 Function template not_fn [func.not.fn]

🔗

template<class F> constexpr unspecified not_fn(F&& f);

In the text that follows:

(1.1)
g is a value of the result of a not_fn invocation,
(1.2)
FD is the type decay_t<F>,
(1.3)
fd is the target object of g ([func.def]) of type FD, direct-non-list-initialized with std::forward<F>(f),
(1.4)
call_args is an argument pack used in a function call expression ([expr.call]) of g.

Mandates: is_constructible_v<FD, F> && is_move_constructible_v<FD> is true.

Returns: A perfect forwarding call wrapper ([func.require]) g with call pattern !invoke(fd, call_args..).

Throws: Any exception thrown by the initialization of fd.

🔗

template<auto f> constexpr unspecified not_fn() noexcept;

In the text that follows:

(6.1)
F is the type of f,
(6.2)
g is a value of the result of a not_fn invocation,
(6.3)
call_args is an argument pack used in a function call expression ([expr.call]) of g.

Mandates: If is_pointer_v<F> || is_member_pointer_v<F> is true, then f != nullptr is true.

Returns: A perfect forwarding call wrapper ([func.require]) g that does not have state entities, and has the call pattern !invoke(f, call_args..).

22.10.14 Function templates bind_front and bind_back [func.bind.partial]

🔗

template<class F, class. Args>
  constexpr unspecified bind_front(F&& f, Args&&. args);
template<class F, class. Args>
  constexpr unspecified bind_back(F&& f, Args&&. args);

Within this subclause:

(1.1)
g is a value of the result of a bind_front or bind_back invocation,
(1.2)
FD is the type decay_t<F>,
(1.3)
fd is the target object of g ([func.def]) of type FD, direct-non-list-initialized with std::forward<F>(f),
(1.4)
BoundArgs is a pack that denotes decay_t<Args>.,
(1.5)
bound_args is a pack of bound argument entities of g ([func.def]) of types BoundArgs.., direct-non-list-initialized with std::forward<Args>(args)., respectively, and
(1.6)
call_args is an argument pack used in a function call expression ([expr.call]) of g.

Mandates: is_constructible_v<FD, F> && is_move_constructible_v<FD> && (is_constructible_v<BoundArgs, Args> && ..) && (is_move_constructible_v<BoundArgs> && ..) is true.

Preconditions: FD meets the Cpp17MoveConstructible requirements.

For each

T {i in BoundArgs, if T {i is an object type, T {i meets the Cpp17MoveConstructible requirements .}_{i meets the Cpp17MoveConstructible requirements .}}_{i is an object type, T {i meets the Cpp17MoveConstructible requirements .}_{i meets the Cpp17MoveConstructible requirements .}}}_{i in BoundArgs, if T {i is an object type, T {i meets the Cpp17MoveConstructible requirements .}_{i meets the Cpp17MoveConstructible requirements .}}_{i is an object type, T {i meets the Cpp17MoveConstructible requirements .}_{i meets the Cpp17MoveConstructible requirements .}}}

Returns: A perfect forwarding call wrapper ([func.require]) g with call pattern:

(4.1)
invoke(fd, bound_args.., call_args..) for a bind_front invocation, or
(4.2)
invoke(fd, call_args.., bound_args..) for a bind_back invocation.

Throws: Any exception thrown by the initialization of the state entities of g ([func.def]).

🔗

template<auto f, class. Args>
  constexpr unspecified bind_front(Args&&. args);
template<auto f, class. Args>
  constexpr unspecified bind_back(Args&&. args);

Within this subclause:

(6.1)
F is the type of f,
(6.2)
g is a value of the result of a bind_front or bind_back invocation,
(6.3)
BoundArgs is a pack that denotes decay_t<Args>.,
(6.4)
bound_args is a pack of bound argument entities of g ([func.def]) of types BoundArgs.., direct-non-list-initialized with std::forward<Args>(args)., respectively, and
(6.5)
call_args is an argument pack used in a function call expression ([expr.call]) of g.

Mandates:

(7.1)
(is_constructible_v<BoundArgs, Args> && ..) is true, and
(7.2)
(is_move_constructible_v<BoundArgs> && ..) is true, and
(7.3)
if is_pointer_v<F> || is_member_pointer_v<F> is true, then f != nullptr is true.

Preconditions: For each

T {i in BoundArgs, T {i meets the Cpp17MoveConstructible requirements .}_{i meets the Cpp17MoveConstructible requirements .}}_{i in BoundArgs, T {i meets the Cpp17MoveConstructible requirements .}_{i meets the Cpp17MoveConstructible requirements .}}

Returns: A perfect forwarding call wrapper ([func.require]) g that does not have a target object, and has the call pattern:

(9.1)
invoke(f, bound_args.., call_args..) for a bind_front invocation, or
(9.2)
invoke(f, call_args.., bound_args..) for a bind_back invocation.

Subclause [func.bind] describes a uniform mechanism for binding arguments of callable objects.

22.10.15.2 Class template is_bind_expression [func.bind.isbind]

🔗

namespace std { template<class T> struct is_bind_expression; / see below }

The class template is_bind_expression can be used to detect function objects generated by bind.

The function template bind uses is_bind_expression to detect subexpressions.

Specializations of the is_bind_expression template shall meet the Cpp17UnaryTypeTrait requirements ([meta.rqmts]).

The implementation provides a definition that has a base characteristic of true_type if T is a type returned from bind, otherwise it has a base characteristic of false_type.

A program may specialize this template for a program-defined type T to have a base characteristic of true_type to indicate that T should be treated as a subexpression in a bind call.

22.10.15.3 Class template is_placeholder [func.bind.isplace]

🔗

namespace std { template<class T> struct is_placeholder; / see below }

The class template is_placeholder can be used to detect the standard placeholders _1, _2, and so on ([func.bind.place]).

The function template bind uses is_placeholder to detect placeholders.

Specializations of the is_placeholder template shall meet the Cpp17UnaryTypeTrait requirements ([meta.rqmts]).

The implementation provides a definition that has the base characteristic of integral_constant<int, J> if T is the type of std::placeholders::_J, otherwise it has a base characteristic of integral_constant<int, 0>.

A program may specialize this template for a program-defined type T to have a base characteristic of integral_constant<int, N> with N > 0 to indicate that T should be treated as a placeholder type.

22.10.15.4 Function template bind [func.bind.bind]

In the text that follows:

(1.1)
g is a value of the result of a bind invocation,
(1.2)
FD is the type decay_t<F>,
(1.3)
fd is an lvalue that is a target object of g ([func.def]) of type FD direct-non-list-initialized with std::forward<F>(f),
(1.4)
$T {i is the {i th type in the template parameter pack BoundArgs,}^{th type in the template parameter pack BoundArgs,}}_{i is the {i th type in the template parameter pack BoundArgs,}^{th type in the template parameter pack BoundArgs,}}$
(1.5)
$TD {i is the type decay_t < T {i >,}_{i >}}_{i is the type decay_t < T {i >,}_{i >}}$
(1.6)
$t {i is the {i th argument in the function parameter pack bound_args,}^{th argument in the function parameter pack bound_args,}}_{i is the {i th argument in the function parameter pack bound_args,}^{th argument in the function parameter pack bound_args,}}$
(1.7)
$td {i is a bound argument entity of g ([func. def]) of type TD {i direct-non-list-initialized with std :: forward < T {i > (t {i),}_{i)}}_{i > (t {i),}_{i)}}}_{i direct-non-list-initialized with std :: forward < T {i > (t {i),}_{i)}}_{i > (t {i),}_{i)}}}}_{i is a bound argument entity of g ([func. def]) of type TD {i direct-non-list-initialized with std :: forward < T {i > (t {i),}_{i)}}_{i > (t {i),}_{i)}}}_{i direct-non-list-initialized with std :: forward < T {i > (t {i),}_{i)}}_{i > (t {i),}_{i)}}}}$
(1.8)
$U {j is the {j th deduced type of the UnBoundArgs & & . parameter of the argument forwarding call wrapper, and}^{th deduced type of the UnBoundArgs & & . parameter of the argument forwarding call wrapper, and}}_{j is the {j th deduced type of the UnBoundArgs & & . parameter of the argument forwarding call wrapper, and}^{th deduced type of the UnBoundArgs & & . parameter of the argument forwarding call wrapper, and}}$
(1.9)
$u {j is the {j th argument associated with U {j .}_{j .}}^{th argument associated with U {j .}_{j .}}}_{j is the {j th argument associated with U {j .}_{j .}}^{th argument associated with U {j .}_{j .}}}$

🔗

template<class F, class. BoundArgs>
  constexpr unspecified bind(F&& f, BoundArgs&&. bound_args);
template<class R, class F, class. BoundArgs>
  constexpr unspecified bind(F&& f, BoundArgs&&. bound_args);

Mandates: is_constructible_v<FD, F> is true.

For each

T {i in BoundArgs, is_constructible_v < TD {i, T {i > is true .}_{i >}}_{i, T {i > is true .}_{i >}}}_{i in BoundArgs, is_constructible_v < TD {i, T {i > is true .}_{i >}}_{i, T {i > is true .}_{i >}}}

Preconditions: FD and each

TD {i meet the Cpp17MoveConstructible and Cpp17Destructible requirements .}_{i meet the Cpp17MoveConstructible and Cpp17Destructible requirements .}

INVOKE(fd,

w {1, w {2, \dots, w {N) ([func. require]) is a valid expression for some values w {1, w {2, \dots, w_{, where has the value}}_{2, \dots, w {, where has the value}_{, where has the value bound_args .}}}_{1, w {2, \dots, w {, where has the value}_{, where has the value bound_args .}}_{2, \dots, w {, where has the value bound_args .}_{N, where N has the value sizeof . (bound_args) .}}}}_{N)}}_{2, \dots, w {N) ([func. require]) is a valid expression for some values w {1, w {2, \dots, w {, where has the value}_{, where has the value bound_args .}}_{2, \dots, w {, where has the value bound_args .}_{N, where N has the value sizeof . (bound_args) .}}}_{1, w {2, \dots, w {, where has the value bound_args .}_{N, where N has the value sizeof . (bound_args) .}}_{2, \dots, w {N, where N has the value sizeof . (bound_args) .}_{N, where N has the value sizeof . (bound_args) .}}}}_{N)}}}_{1, w {2, \dots, w {N) ([func. require]) is a valid expression for some values w {1, w {2, \dots, w {, where has the value}_{, where has the value bound_args .}}_{2, \dots, w {, where has the value bound_args .}_{N, where N has the value sizeof . (bound_args) .}}}_{1, w {2, \dots, w {, where has the value bound_args .}_{N, where N has the value sizeof . (bound_args) .}}_{2, \dots, w {N, where N has the value sizeof . (bound_args) .}_{N, where N has the value sizeof . (bound_args) .}}}}_{N)}}_{2, \dots, w {N) ([func. require]) is a valid expression for some values w {1, w {2, \dots, w {, where has the value bound_args .}_{N, where N has the value sizeof . (bound_args) .}}_{2, \dots, w {N, where N has the value sizeof . (bound_args) .}_{N, where N has the value sizeof . (bound_args) .}}}_{1, w {2, \dots, w {N, where N has the value sizeof . (bound_args) .}_{N, where N has the value sizeof . (bound_args) .}}_{2, \dots, w {N, where N has the value sizeof . (bound_args) .}_{N, where N has the value sizeof . (bound_args) .}}}}_{N)}}}

Returns: An argument forwarding call wrapper g ([func.require]).

A program that attempts to invoke a volatile-qualified g is ill-formed.

When g is not volatile-qualified, invocation of g(

u {1, u {2, \dots, u {M) is expression-equivalent ([defns. expression. equivalent]) to INVOKE (static_cast < V {fd > (v {fd), static_cast <}_{fd), static_cast <}}_{fd > (v {fd), static_cast <}_{fd), static_cast <}}}_{M)}}_{2, \dots, u {M) is expression-equivalent ([defns. expression. equivalent]) to INVOKE (static_cast < V {fd > (v {fd), static_cast <}_{fd), static_cast <}}_{fd > (v {fd), static_cast <}_{fd), static_cast <}}}_{M)}}}_{1, u {2, \dots, u {M) is expression-equivalent ([defns. expression. equivalent]) to INVOKE (static_cast < V {fd > (v {fd), static_cast <}_{fd), static_cast <}}_{fd > (v {fd), static_cast <}_{fd), static_cast <}}}_{M)}}_{2, \dots, u {M) is expression-equivalent ([defns. expression. equivalent]) to INVOKE (static_cast < V {fd > (v {fd), static_cast <}_{fd), static_cast <}}_{fd > (v {fd), static_cast <}_{fd), static_cast <}}}_{M)}}}

Throws: Any exception thrown by the initialization of the state entities of g.

[Note 1:

If all of FD and

TD {i meet the requirements of Cpp17CopyConstructible, then the return type meets the requirements of Cpp17CopyConstructible .}_{i meet the requirements of Cpp17CopyConstructible, then the return type meets the requirements of Cpp17CopyConstructible .}

— end note]

The values of the bound arguments

The value of the target argument

v {fd is fd and its corresponding type V {fd is cv FD & .}_{fd is cv FD & .}}_{fd is fd and its corresponding type V {fd is cv FD & .}_{fd is cv FD & .}}

22.10.15.5 Placeholders [func.bind.place]

namespace std::placeholders { / M is the number of placeholders see below _1; see below _2; ⋮ see below _M; }

The number M of placeholders is implementation-defined.

All placeholder types meet the Cpp17DefaultConstructible and Cpp17CopyConstructible requirements, and their default constructors and copy/move constructors are constexpr functions that do not throw exceptions.

It is implementation-defined whether placeholder types meet the Cpp17CopyAssignable requirements, but if so, their copy assignment operators are constexpr functions that do not throw exceptions.

Placeholders should be defined as: inline constexpr unspecified _1{};

If they are not, they are declared as: extern unspecified _1;

Placeholders are freestanding items ([freestanding.item]).

22.10.16 Function template mem_fn [func.memfn]

🔗

template<class R, class T> constexpr unspecified mem_fn(R T::* pm) noexcept;

Returns: A simple call wrapper ([func.require]) fn with call pattern invoke(pmd, call_args..), where pmd is the target object of fn of type R T::* direct-non-list-initialized with pm, and call_args is an argument pack used in a function call expression ([expr.call]) of fn.

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.1 General [func.wrap.general]

Subclause [func.wrap] describes polymorphic wrapper classes that encapsulate arbitrary callable objects.

Let t be an object of a type that is a specialization of function, copyable_function, or move_only_function, such that the target object x of t has a type that is a specialization of function, copyable_function, or move_only_function.

Each argument of the invocation of x evaluated as part of the invocation of t may alias an argument in the same position in the invocation of t that has the same type, even if the corresponding parameter is not of reference type.

[Example 1: move_only_function<void(T)> f{copyable_function<void(T)>{[](T) {}; T t; f(t); / it is unspecified how many copies of T are made — end example]

Recommended practice: Implementations should avoid double wrapping when constructing polymorphic wrappers from one another.

22.10.17.2 Class bad_function_call [func.wrap.badcall]

An exception of type bad_function_call is thrown by function::operator() ([func.wrap.func.inv]) when the function wrapper object has no target.

namespace std { class bad_function_call : public exception { public: / see [exception] for the specification of the special member functions const char* what() const noexcept override; }; }

🔗

const char* what() const noexcept override;

Returns: An implementation-defined ntbs.

22.10.17.3 Class template function [func.wrap.func]

22.10.17.3.1 General [func.wrap.func.general]

🔗

namespace std { template<class R, class. ArgTypes> class function<R(ArgTypes..)> { public: using result_type = R; / [func.wrap.func.con], construct/copy/destroy function() noexcept; function(nullptr_t) noexcept; function(const function&); function(function&&) noexcept; template<class F> function(F&&); function& operator=(const function&); function& operator=(function&&); function& operator=(nullptr_t) noexcept; template<class F> function& operator=(F&&); template<class F> function& operator=(reference_wrapper<F>) noexcept; ~function(); / [func.wrap.func.mod], function modifiers void swap(function&) noexcept; / [func.wrap.func.cap], function capacity explicit operator bool() const noexcept; / [func.wrap.func.inv], function invocation R operator()(ArgTypes..) const; / [func.wrap.func.targ], function target access const type_info& target_type() const noexcept; template<class T> T* target() noexcept; template<class T> const T* target() const noexcept; }; template<class R, class. ArgTypes> function(R(*)(ArgTypes..) -> function<R(ArgTypes..)>; template<class F> function(F) -> function<see below>; }

The function class template provides polymorphic wrappers that generalize the notion of a function pointer.

Wrappers can store, copy, and call arbitrary callable objects ([func.def]), given a call signature ([func.def]).

The function class template is a call wrapper ([func.def]) whose call signature ([func.def]) is R(ArgTypes..).

[Note 1:

The types deduced by the deduction guides for function might change in future revisions of C++.

— end note]

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

🔗

function() noexcept;

Postconditions: !*this.

🔗

function(nullptr_t) noexcept;

Postconditions: !*this.

function(const function& f);

22.10.2 Header <functional> synopsis [functional.syn]

22.10.3 Definitions [func.def]

22.10.4 Requirements [func.require]

22.10.5 invoke functions [func.invoke]

22.10.6 Class template reference_wrapper [refwrap]

22.10.6.1 General [refwrap.general]

22.10.6.2 Constructors [refwrap.const]

22.10.6.3 Assignment [refwrap.assign]

22.10.6.4 Access [refwrap.access]

22.10.6.5 Invocation [refwrap.invoke]

22.10.6.6 Comparisons [refwrap.comparisons]

22.10.6.8 common_reference related specializations [refwrap.common.ref]

22.10.7 Arithmetic operations [arithmetic.operations]

22.10.7.1 General [arithmetic.operations.general]

22.10.7.2 Class template plus [arithmetic.operations.plus]

22.10.7.3 Class template minus [arithmetic.operations.minus]

22.10.7.4 Class template multiplies [arithmetic.operations.multiplies]

22.10.7.5 Class template divides [arithmetic.operations.divides]

22.10.7.6 Class template modulus [arithmetic.operations.modulus]

22.10.7.7 Class template negate [arithmetic.operations.negate]

22.10.8.2 Class template equal_to [comparisons.equal.to]

22.10.8.3 Class template not_equal_to [comparisons.not.equal.to]

22.10.8.4 Class template greater [comparisons.greater]

22.10.8.5 Class template less [comparisons.less]

22.10.8.6 Class template greater_equal [comparisons.greater.equal]

22.10.8.7 Class template less_equal [comparisons.less.equal]

22.10.8.8 Class compare_three_way [comparisons.three.way]

22.10.9 Concept-constrained comparisons [range.cmp]

22.10.10 Logical operations [logical.operations]

22.10.10.1 General [logical.operations.general]

22.10.10.2 Class template logical_and [logical.operations.and]

22.10.10.3 Class template logical_or [logical.operations.or]

22.10.10.4 Class template logical_not [logical.operations.not]

22.10.11.2 Class template bit_and [bitwise.operations.and]

22.10.11.3 Class template bit_or [bitwise.operations.or]

22.10.11.4 Class template bit_xor [bitwise.operations.xor]

22.10.11.5 Class template bit_not [bitwise.operations.not]

22.10.12 Class identity [func.identity]

22.10.13 Function template not_fn [func.not.fn]

22.10.14 Function templates bind_front and bind_back [func.bind.partial]

22.10.15.2 Class template is_bind_expression [func.bind.isbind]

22.10.15.3 Class template is_placeholder [func.bind.isplace]

22.10.15.4 Function template bind [func.bind.bind]

22.10.15.5 Placeholders [func.bind.place]

22.10.16 Function template mem_fn [func.memfn]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.1 General [func.wrap.general]

22.10.17.2 Class bad_function_call [func.wrap.badcall]

22.10.17.3 Class template function [func.wrap.func]

22.10.17.3.1 General [func.wrap.func.general]

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

22.10.17.3.3 Modifiers [func.wrap.func.mod]

22.10.17.3.4 Capacity [func.wrap.func.cap]

22.10.17.3.5 Invocation [func.wrap.func.inv]

22.10.17.3.6 Target access [func.wrap.func.targ]

22.10.17.3.7 Null pointer comparison operator functions [func.wrap.func.nullptr]

22.10.17.3.8 Specialized algorithms [func.wrap.func.alg]

22.10.17.4.2 Class template move_only_function [func.wrap.move.class]

22.10.17.4.3 Constructors, assignments, and destructor [func.wrap.move.ctor]

22.10.17.4.4 Invocation [func.wrap.move.inv]

22.10.17.4.5 Utility [func.wrap.move.util]

22.10.17.5.2 Class template copyable_function [func.wrap.copy.class]

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

22.10.17.5.4 Invocation [func.wrap.copy.inv]

22.10.17.5.5 Utility [func.wrap.copy.util]

22.10.17.6.2 Class template function_ref [func.wrap.ref.class]

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

22.10.17.6.4 Invocation [func.wrap.ref.inv]

22.10.17.6.5 Deduction guides [func.wrap.ref.deduct]

22.10.18.2 Class template default_searcher [func.search.default]

22.10.18.3 Class template boyer_moore_searcher [func.search.bm]

22.10.18.4 Class template boyer_moore_horspool_searcher [func.search.bmh]