std::move_only_function

< cpp‎ | utility‎ | functional

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

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

Non-member functions

swap(std::move_only_function) (C++23)	overloads the std::swap algorithm (function)
operator== (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.

Like std::function, if R is a reference type that can be bound to an rvalue, std::move_only_function may wrap function objects that return by value, in which case a call to such std::move_only_function always returns a dangling reference.

std::move_only_function<const int&() const> uf([]{ return 42; });
int x = uf(); // Undefined behavior: the result of uf() is a dangling reference

Example