std::move_only_function - cppreference.com (original) (raw)
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 (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::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
| (constructor) | constructs a new std::move_only_function object (public member function) [edit] |
|---|---|
| (destructor) | destroys a std::move_only_function object (public member function) [edit] |
| operator= | replaces or destroys the target (public member function) [edit] |
| swap | swaps the targets of two std::move_only_function objects (public member function) [edit] |
| operator bool | checks if the std::move_only_function has a target (public member function) [edit] |
| operator() | invokes the target (public member function) [edit] |
[edit] Non-member functions
[edit] Notes
Implementations may 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 reference to a temporary object is forbidden. See also std::function Notes.
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
| __cpp_lib_move_only_function | 202110L | (C++23) | std::move_only_function |
[edit] Example
#include #include #include int main() { std::packaged_task<double()> packaged_task({ return 3.14159; }); std::future future = packaged_task.get_future(); auto lambda = task = std::move(packaged_task) mutable { task(); }; // std::function<void()> function = std::move(lambda); // Error std::move_only_function<void()> function = std::move(lambda); // OK function(); std::cout << future.get(); }
Output:
[edit] See also
| | copyable wrapper of any copy constructible callable object (class template) [edit] | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | non-owning wrapper of any callable object (class template) [edit] | | | copyable wrapper of any copy constructible callable object that supports qualifiers in a given call signature (class template) [edit] |