NAME¶

std::move_only_function::move_only_function - std::move_only_function::move_only_function

Synopsis¶

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 > (5) (since C++23)
move_only_function( F&& f );
template< class T, class... CArgs >
explicit move_only_function( std::in_place_type_t<T>, CArgs&&... (6) (since C++23)
args );
template< class T, class U, class... CArgs >

explicit move_only_function( std::in_place_type_t<T>, (7) (since C++23)

std::initializer_list<U> il,
CArgs&&... args );

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 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>
std::is_invocable_r_v<R, VT, Args...> &&
noexcept(false)
std::is_invocable_r_v<R, VT&, Args...>
std::is_nothrow_invocable_r_v<R, VT, Args...> &&
noexcept(true)
std::is_nothrow_invocable_r_v<R, VT&, Args...>
std::is_invocable_r_v<R, const VT, Args...> &&
const noexcept(false)
std::is_invocable_r_v<R, const VT&, Args...>
std::is_nothrow_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...>
&& 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¶

constructor constructs a new std::function instance
(public member function of std::function<R(Args...)>)

Category:¶

* Todo no example