Namespaces
Variants
Views
Actions

std::move_only_function

From cppreference.com
< cpp‎ | utility‎ | functional
 
 
Utilities library
General utilities
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++14)
(C++11)

(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)

Elementary string conversions
(C++17)
(C++17)

Stacktrace
 
Function objects
Function wrappers
(C++11)
move_only_function
(C++23)
(C++11)
Partial function application
(C++20)
(C++11)
Function invocation
(C++17)(C++23)
Identity function object
(C++20)
Reference wrappers
(C++11)(C++11)
Transparent operator wrappers
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
Negators
(C++17)
Searchers
Constrained comparators
Old binders and adaptors
(until C++17)
(until C++17)
(until C++17)
(until C++17)
(until C++17)(until C++17)(until C++17)(until C++17)
(until C++20)
(until C++20)
(until C++17)(until C++17)
(until C++17)(until C++17)

(until C++17)
(until C++17)(until C++17)(until C++17)(until C++17)
(until C++20)
(until C++20)
 
 
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.

Contents

[edit] Member types

Type Definition
result_type R

[edit] Member functions

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

[edit] Non-member functions

overloads the std::swap algorithm
(function) [edit]
compares a std::move_only_function with nullptr
(function) [edit]

[edit] 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

[edit] Example

[edit] See also

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