Namespaces
Variants

    std::move_only_function::move_only_function

    From cppreference.com
     
    C++
     
    Utilities library
    General utilities
    Relational operators (deprecated in C++20)
     
    Function objects
    Function invocation
    (C++17)(C++23)
    Identity function object
    (C++20)
    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)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    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++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*)
     
    std::move_only_function
     
    move_only_function() noexcept;
    		 (1) (since C++23)
    move_only_function( std::nullptr_t ) noexcept;
    		 (2) (since C++23)
    move_only_function( move_only_function&& other ) noexcept;
    		 (3) (since C++23)
    move_only_function( const move_only_function& ) = delete;
    		 (4) (since C++23)
    template< class F > move_only_function( F&& f );
    		 (5) (since C++23)
    template< class T, class... CArgs > explicit move_only_function( std::in_place_type_t<T>, CArgs&&... args );
    		 (6) (since C++23)
    template< class T, class U, class... CArgs > explicit move_only_function( std::in_place_type_t<T>, std::initializer_list<U> il, CArgs&&... args );
    		 (7) (since C++23)
    See More

    Creates a new std::move_only_function.

    1,2) Default constructor and the constructor taking nullptr construct an empty std::move_only_function.
    3) Move constructor constructs a std::move_only_function whose target is that of other. other is in a valid but unspecified state after move construction.
    4) Copy constructor is deleted. std::move_only_function does not satisfy CopyConstructible.
    5) Let VT be std::decay_t<F>. If f is a null function pointer, a null pointer to member value, or an empty std::move_only_function (may be any other specialization), then constructs an empty std::move_only_function. Otherwise, constructs a std::move_only_function whose target is of type VT and direct-non-list-initialized with std::forward<F>(f).
    • This overload participates in overload resolution only if VT is neither same as move_only_function nor a specialization of std::in_place_type_t, and /*is-callable-from*/<VT> (see below) is true.
    • The program is ill-formed if std::is_constructible_v<VT, F> is not true.
    6) Let VT be std::decay_t<T>. Constructs a std::move_only_function whose target is of type VT and direct-non-list-initialized with std::forward<CArgs>(args)....
    • This overload participates in overload resolution only if both std::is_constructible_v<VT, CArgs...> and /*is-callable-from*/<VT> (see below) are true.
    • The program is ill-formed if VT is not the same type as T.
    7) Let VT be std::decay_t<T>. Constructs a std::move_only_function whose target is of type VT and direct-non-list-initialized with il, std::forward<CArgs>(args)....
    • This overload participates in overload resolution only if both std::is_constructible_v<VT, std::initializer_list<U>&, CArgs...> and /*is-callable-from*/<VT> (see below) are true.
    • The program is ill-formed if VT is not the same type as T.

    For constructors (5-7), the behavior is undefined if VT does not satisfy the Destructible requirements, or std::is_move_constructible_v<VT> is true but VT does not satisfy the MoveConstructible requirements.

    The constant /*is-callable-from*/<VT> is dependent on cv, ref, and noex in the template parameter of std::move_only_function as below:

    cv ref noexcept(noex) /*is-callable-from*/<VT>
    noexcept(false) std::is_invocable_r_v<R, VT, Args...> && std::is_invocable_r_v<R, VT&, Args...>
    noexcept(true) std::is_nothrow_invocable_r_v<R, VT, Args...> && std::is_nothrow_invocable_r_v<R, VT&, Args...>
    const noexcept(false) std::is_invocable_r_v<R, const VT, Args...> && std::is_invocable_r_v<R, const VT&, Args...>
    const noexcept(true) std::is_nothrow_invocable_r_v<R, const VT, Args...> && std::is_nothrow_invocable_r_v<R, const VT&, Args...>
    & noexcept(false) std::is_invocable_r_v<R, VT&, Args...>
    & noexcept(true) std::is_nothrow_invocable_r_v<R, VT&, Args...>
    const & noexcept(false) std::is_invocable_r_v<R, const VT&, Args...>
    const & noexcept(true) std::is_nothrow_invocable_r_v<R, const VT&, Args...>
    && noexcept(false) std::is_invocable_r_v<R, VT, Args...>
    && noexcept(true) std::is_nothrow_invocable_r_v<R, VT, Args...>
    const && noexcept(false) std::is_invocable_r_v<R, const VT, Args...>
    const && noexcept(true) std::is_nothrow_invocable_r_v<R, const VT, Args...>

    Parameters

    other - another std::move_only_function to move from
    f - a function or a Callable object to wrap
    args - arguments to construct the target object
    il - std::initializer_list to construct the target object

    Exceptions

    5-7) May throw std::bad_alloc on allocation failure or propagate the exception thrown by the initialization of the target. No exception is thrown if VT is a function pointer type or a specialization of std::reference_wrapper.

    Example

    This section is incomplete
    Reason: no example

    See also

    		 constructs a new std::function instance
    (public member function of std::function<R(Args...)>) [edit]
    		constructs a new std::copyable_function object
    (public member function of std::copyable_function) [edit]