std::copyable_function
| Defined in header <functional>
|
||
template< class... >
class copyable_function; // not defined
|
(1) | (since C++26) |
template< class R, class... Args >
class copyable_function<R(Args...)>;
template< class R, class... Args >
class copyable_function<R(Args...) noexcept>;
template< class R, class... Args >
class copyable_function<R(Args...) &>;
template< class R, class... Args >
class copyable_function<R(Args...) & noexcept>;
template< class R, class... Args >
class copyable_function<R(Args...) &&>;
template< class R, class... Args >
class copyable_function<R(Args...) && noexcept>;
template< class R, class... Args >
class copyable_function<R(Args...) const>;
template< class R, class... Args >
class copyable_function<R(Args...) const noexcept>;
template< class R, class... Args >
class copyable_function<R(Args...) const &>;
template< class R, class... Args >
class copyable_function<R(Args...) const & noexcept>;
template< class R, class... Args >
class copyable_function<R(Args...) const &&>;
template< class R, class... Args >
class copyable_function<R(Args...) const && noexcept>;
|
(2) | (since C++26) |
Class template std::copyable_function is a general-purpose polymorphic function wrapper. std::copyable_function objects can store and invoke any CopyConstructible Callable target functions, lambda expressions, bind expressions, or other function objects, as well as pointers to member functions and pointers to member objects.
The stored callable object is called the target of std::copyable_function. If a std::copyable_function contains no target, it is called empty. Unlike std::function, invoking an empty std::copyable_function results in undefined behavior.
std::copyable_functions supports every possible combination of cv-qualifiers (not including volatile), ref-qualifiers, and noexcept-specifiers provided in its template parameter. These qualifiers and specifier (if any) are added to its operator().
std::copyable_function satisfies the requirements of CopyConstructible and CopyAssignable.
Member types
| Type | Definition |
result_type
|
R
|
Member functions
constructs a new std::copyable_function object (public member function) | |
destroys a std::copyable_function object (public member function) | |
| replaces or destroys the target (public member function) | |
swaps the targets of two std::copyable_function objects (public member function) | |
checks if the std::copyable_function has a target (public member function) | |
| invokes the target (public member function) |
Non-member functions
(C++26) |
overloads the std::swap algorithm (function) |
(C++26) |
compares a std::copyable_function with nullptr (function) |
Notes
Implementations may store a callable object of small size within the std::copyable_function object. Such small object optimization is effectively required for function pointers and std::reference_wrapper specializations, and can only be applied to types T for which std::is_nothrow_move_constructible_v<T> is true.
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_copyable_function |
202306L |
(C++26) | std::copyable_function
|
Example
| This section is incomplete Reason: no example |
See also
(C++11) |
copyable wrapper of any copy constructible callable object (class template) |
(C++23) |
move-only wrapper of any callable object that supports qualifiers in a given call signature (class template) |
(C++26) |
non-owning wrapper of any callable object (class template) |