cpp / latest / utility / functional / move_only_function.html /

std::move_only_function

Defined in header <functional>
template< class... >
class move_only_function; // not defined
(since C++23)
template< class R, class... Args >
class move_only_function<R(Args...)>;
template< class R, class... Args >
class move_only_function<R(Args...) noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) &>;
template< class R, class... Args >
class move_only_function<R(Args...) & noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) &&>;
template< class R, class... Args >
class move_only_function<R(Args...) && noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) const>;
template< class R, class... Args >
class move_only_function<R(Args...) const noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) const &>;
template< class R, class... Args >
class move_only_function<R(Args...) const & noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) const &&>;
template< class R, class... Args >
class move_only_function<R(Args...) const && noexcept>;
(since C++23)

Class template std::move_only_function is a general-purpose polymorphic function wrapper. std::move_only_function objects can store and invoke any constructible (not required to be move constructible) 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::move_only_function. If a std::move_only_function contains no target, it is called empty. Unlike std::function, invoking an empty std::move_only_function results in undefined behavior.

std::move_only_functions supports every possible combination of cv-qualifiers, ref-qualifiers, and noexcept-specifiers not including volatile provided in its template parameter. These qualifiers and specifier (if any) are added to its operator().

std::move_only_function satisfies the requirements of MoveConstructible and MoveAssignable, but does not satisfy CopyConstructible or CopyAssignable.

Member types

Type Definition
result_type R

Member functions

(C++23)
constructs a new std::move_only_function object
(public member function)
(C++23)
destroys a std::move_only_function object
(public member function)
(C++23)
replaces or destroys the target
(public member function)
(C++23)
swaps the targets of two std::move_only_function objects
(public member function)
(C++23)
checks if the std::move_only_function has a target
(public member function)
(C++23)
invokes the target
(public member function)

Non-member functions

(C++23)
overloads the std::swap algorithm
(function)
(C++23)
compares a std::move_only_function with nullptr
(function)

Notes

Implementations are recommended to store a callable object of small size within the std::move_only_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.

If a std::move_only_function returning a reference is initialized from a function or function object returning a prvalue (including a lambda expression without a trailing-return-type), the program is ill-formed because binding the returned referenced to a temporary object is forbidden.

Feature testing macro: __cpp_lib_move_only_function.

Example

See also

(C++11)
wraps callable object of any copy constructible type with specified function call signature
(class template)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/functional/move_only_function