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)
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)

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...)> )
constructs a new std::copyable_function object
(public member function of std::copyable_function )
Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/move_only_function/move_only_function&oldid=178043 "