# std::move_only_function

> C++ Atlas: `cppatlas.com/w/cpp/utility/functional/move_only_function` | Source: https://en.cppreference.com/w/cpp/utility/functional/move_only_function | Domain: Utility | Standards: C++11, C++23, C++26

Class template std::move_only_function is a general-purpose polymorphic function wrapper.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <functional>

template< class... >
class move_only_function; // not defined // (1) (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>; // (2) (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_function`s 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*.

### Member types

**Type — Definition**

- `result_type`: `R`

### Member functions

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

### Non-member functions

- `swap(std::move_only_function)` (C++23): specializes the `std::swap` algorithm (function)
- `operator==` (C++23): compares a `std::move_only_function` with `nullptr` (function)

### 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` |

### Example

```cpp
#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();
}
```

Output:

```text
3.14159
```

### See also

- [`function`](https://en.cppreference.com/w/cpp/utility/functional/function) (C++11): copyable wrapper of any copy constructible callable object (class template)
- [`function_ref`](https://en.cppreference.com/w/cpp/utility/functional/function_ref) (C++26): non-owning wrapper of any callable object (class template)
- [`copyable_function`](https://en.cppreference.com/w/cpp/utility/functional/copyable_function) (C++26): copyable wrapper of any copy constructible callable object that supports qualifiers in a given call signature (class template)

---
Attribution: content from https://en.cppreference.com/w/cpp/utility/functional/move_only_function (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.