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.
[edit] Function invocationThe 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)
C, then INVOKE(f, obj, arg_1, arg_2, ..., arg_N) is equivalent to:Obj is a specialization of std::reference_wrapperC, then INVOKE(mptr, obj) is equivalent to:Obj is a specialization of std::reference_wrapperINVOKE(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<R>(f, arg_0, arg_1, arg_2, ..., arg_N) is defined as follows:
R is (possibly cv-qualified) voidINVOKE(f, arg_0, arg_1, arg_2, ..., arg_N)).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))
INVOKE<R>(f, arg_0, arg_1, arg_2, ..., arg_N) is ill-formed.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).
These polymorphic wrapper classes provide support for storing arbitrary function objects.
copyable wrapper of any copy constructible callable objectstd::identity is the identity function object: it returns its argument unchanged.
function object that returns its argument unchangedstd::bind_front and std::bind provide support for partial function application, i.e. binding arguments to functions to produce new functions.
bind a variable number of arguments, in order, to a function objectstd::bind expression or can be used as one
std::bind expression
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 holdsSearchers implementing several string searching algorithms are provided and can be used either directly or with std::search.
[edit] Reference wrappersReference wrappers allow reference arguments to be stored in copyable function objects:
Transparent function objectsAssociative containers and unordered associative containers(since C++20) provide heterogeneous lookup and erasure(since C++23) operations, but they are only enabled if the supplied function object type T is transparent : the qualified identifier T::is_transparent is valid and denotes a type.
All transparent function object types in the standard library define a nested type is_transparent. However, user-defined transparent function object types do not need to directly provide is_transparent as a nested type: it can be defined in a base class, as long as T::is_transparent satisfies the transparent requirement stated above.
C++ defines the following function objects that represent common arithmetic and logical operations.
The void specializations deduce their parameter types and return types from their arguments, they are all transparent.
(since C++14) Arithmetic operations function object implementing x + yThe following comparison function objects are constrained.
ranges::equal_to and ranges::not_equal_to) require the types of the arguments to satisfy equality_comparable_with.ranges::less, ranges::greater, ranges::less_equal, and ranges::greater_equal) require the types of the arguments to satisfy totally_ordered_with.compare_three_way) requires the type to model three_way_comparable_with.All these function objects are transparent.
(since C++20) Helper itemsFollowing exposition-only items are used for several components in the standard library but they are not part of the interface of the standard library.
template< class Fn, class... Args >concept /*callable*/ =
requires (Fn&& fn, Args&&... args) {
std::forward<Fn>(fn)(std::forward<Args>(args)...);
concept /*nothrow-callable*/ =
/*callable*/<Fn, Args...> &&
requires (Fn&& fn, Args&&... args) {
{ std::forward<Fn>(fn)(std::forward<Args>(args)...) } noexcept;
template< const auto& T >
using /*decayed-typeof*/ = decltype(auto(T));
Several utilities that provided early functional support are deprecated and removed:
Base(deprecated in C++11)(removed in C++17)
adaptor-compatible unary function base class(deprecated in C++11)(removed in C++17)
adaptor-compatible binary function base class(deprecated in C++11)(removed in C++17)
function object holding a binary function and one of its arguments(deprecated in C++11)(removed in C++17)
binds one argument to a binary function(deprecated in C++11)(removed in C++17)
adaptor-compatible wrapper for a pointer to unary function(deprecated in C++11)(removed in C++17)
adaptor-compatible wrapper for a pointer to binary function(deprecated in C++11)(removed in C++17)
creates an adaptor-compatible function object wrapper from a pointer to function(deprecated in C++11)(removed in C++17)
wrapper for a pointer to nullary or unary member function, callable with a pointer to object(deprecated in C++11)(removed in C++17)
creates a wrapper from a pointer to member function, callable with a pointer to object(deprecated in C++11)(removed in C++17)
wrapper for a pointer to nullary or unary member function, callable with a reference to object(deprecated in C++11)(removed in C++17)
creates a wrapper from a pointer to member function, callable with a reference to object(deprecated in C++17)(removed in C++20)
wrapper function object returning the complement of the unary predicate it holds(deprecated in C++17)(removed in C++20)
wrapper function object returning the complement of the binary predicate it holds(deprecated in C++17)(removed in C++20)
constructs custom std::unary_negate object(deprecated in C++17)(removed in C++20)
constructs custom std::binary_negate objectThe following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR Applied to Behavior as published Correct behavior LWG 185 C++98 using function objects improved the program efficiency removed the claim LWG 660 C++98 function objects for bitwise operations are missing added LWG 2149 C++98 function objects taking one or two arguments were required toINVOKE did not handle std::reference_wrapper correctly handles correctly LWG 2420 C++11 INVOKE<R> did not discard the return value if R is void discards the return value in this case LWG 2926
INVOKE operation with a return
R was INVOKE(f, t1, t2, ..., tN, R) changed to
INVOKE<R>(f, t1, t2, ..., tN) LWG 3655 C++11 INVOKE did not handle unions correctly
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4