[func.wrap.move.class] (original) (raw)

22 General utilities library [utilities]

22.10 Function objects [function.objects]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.4 Move-only wrapper [func.wrap.move]

22.10.17.4.2 Class template move_only_function [func.wrap.move.class]

namespace std { template<class R, class... ArgTypes> class move_only_function<R(ArgTypes...) cv _ref_ noexcept(_noex_)> { public: using result_type = R; move_only_function() noexcept; move_only_function(nullptr_t) noexcept; move_only_function(move_only_function&&) noexcept;template<class F> move_only_function(F&&);template<class T, class... Args> explicit move_only_function(in_place_type_t<T>, Args&&...);template<class T, class U, class... Args> explicit move_only_function(in_place_type_t<T>, initializer_list<U>, Args&&...); move_only_function& operator=(move_only_function&&); move_only_function& operator=(nullptr_t) noexcept;template<class F> move_only_function& operator=(F&&);~move_only_function();explicit operator bool() const noexcept; R operator()(ArgTypes...) cv ref noexcept(noex);void swap(move_only_function&) noexcept;friend void swap(move_only_function&, move_only_function&) noexcept;friend bool operator==(const move_only_function&, nullptr_t) noexcept;private: template<class VT> static constexpr bool is-callable-from = see below; };}

The move_only_function class template provides polymorphic wrappers that generalize the notion of a callable object ([func.def]).

These wrappers can store, move, and call arbitrary callable objects, given a call signature.

Recommended practice: Implementations should avoid the use of dynamically allocated memory for a small contained value.

[Note 1:

Such small-object optimization can only be applied to a type Tfor which is_nothrow_move_constructible_v<T> is true.

— _end note_]