Function objects - cppreference.com (original) (raw)

A function object is any object for which the function call operator is defined. C++ provides many built-in function objects as well as support for creation and manipulation of new function objects.

Contents

• 1 Function invocation
• 2 Function wrappers
• 3 Identity
• 4 Partial function application
• 5 Negators
• 6 Searchers
• 7 Reference wrappers
• 8 Transparent function objects
• 9 Operator function objects
  • 9.1 Arithmetic operations
  • 9.2 Comparisons
  • 9.3 Logical operations
  • 9.4 Bitwise operations
• 10 Constrained comparison function objects
• 11 Helper items
• 12 Old binders and adaptors
  • 12.1 Base
  • 12.2 Binders
  • 12.3 Function adaptors
• 13 Defect reports

[edit] Function invocation

| The exposition-only operation INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) is defined as follows:Let type Obj be the unqualified type of arg_0 (i.e., std::remove_cv<std::remove_reference<decltype(arg_0)>::type>::type) If f is a pointer to member function of class C, then INVOKE(f, obj, arg_1, arg_2, ..., arg_N) is equivalent to: If std::is_same<C, Obj>::value || std::is_base_of<C, Obj>::value is true (obj.*f)(arg_1, arg_2, ..., arg_N) (invoke the member function on the object). If Obj is a specialization of std::reference_wrapper (obj.get().*f)(arg_1, arg_2, ..., arg_N) (invoke the member function on the specially referred object). Otherwise ((*obj).*f)(arg_1, arg_2, ..., arg_N) (invoke the member function on the dereferenced object). Otherwise, if N == 0 and f is a pointer to data member of class C, then INVOKE(mptr, obj) is equivalent to: If std::is_same<C, Obj>::value | | std::is_base_of<C, Obj>::value is true obj.*mptr (access the data member of the object). If Obj is a specialization of std::reference_wrapper obj.get().*mptr (access the data member of the specially referred object). Otherwise (*obj).*mptr (access the data member of the dereferenced object). Otherwise INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) is equivalent to f(arg_0, arg_1, arg_2, ..., arg_N) (invoke the callable). The exposition-only operation INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) is defined as follows: If R is (possibly cv-qualified) void static_cast<void>(INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N)). Otherwise INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) implicitly converted to R. Let type Actual be decltype(INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N)) If std::reference_converts_from_temporary_v <R, Actual> is true INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) is ill-formed. (since C++23) | (since C++11) | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |

std::invoke and std::invoke_r(since C++23) can invoke any Callable object with given arguments according to the rules of _INVOKE_ and _INVOKE<R>_(since C++23).

| | invokes any Callable object with given arguments and possibility to specify return type(since C++23) (function template) [edit] | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

[edit] Function wrappers

These polymorphic wrapper classes provide support for storing arbitrary function objects.

[edit] Identity

std::identity is the identity function object: it returns its argument unchanged.

| | function object that returns its argument unchanged (class) [edit] | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

[edit] Partial function application

std::bind_front and std::bind provide support for partial function application, i.e. binding arguments to functions to produce new functions.

[edit] Negators

std::not_fn creates a function object that negates the result of the callable object passed to it.

| | creates a function object that returns the complement of the result of the function object it holds (function template) [edit] | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

[edit] Searchers

Searchers implementing several string searching algorithms are provided and can be used either directly or with std::search.

[edit] Reference wrappers

Reference wrappers allow reference arguments to be stored in copyable function objects:

[edit] Operator function objects

C++ defines the following function objects that represent common arithmetic and logical operations.

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.