std::move_only_function

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.

[edit] Member types

[edit] Member functions

[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.

[edit] Example

#include <functional>
#include <future>
#include <iostream>
 
int main()
{
    std::packaged_task<double()> packaged_task([](){ return 3.14159; });
 
    std::future<double> 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();
}

3.14159

[edit] See also