Namespaces
Variants

std::move_only_function:: move_only_function

From cppreference.net
C++
Utilities library
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) (desde C++23)
move_only_function ( std:: nullptr_t ) noexcept ;
(2) (desde C++23)
move_only_function ( move_only_function && other ) noexcept ;
(3) (desde C++23)
move_only_function ( const move_only_function & ) = delete ;
(4) (desde C++23)
template < class F >
move_only_function ( F && f ) ;
(5) (desde C++23)
template < class T, class ... CArgs >
explicit move_only_function ( std:: in_place_type_t < T > , CArgs && ... args ) ;
(6) (desde 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) (desde C++23)

Crea un nuevo std::move_only_function .

1,2) El constructor por defecto y el constructor que toma nullptr construyen un std::move_only_function vacío.
3) El constructor de movimiento construye un std::move_only_function cuyo objetivo es el de other . other queda en un estado válido pero no especificado después de la construcción por movimiento.
4) El constructor de copia está eliminado. std::move_only_function no satisface CopyConstructible .
5) Sea VT igual a std:: decay_t < F > . Si f es un puntero a función nulo, un puntero a miembro nulo, o un std::move_only_function vacío (puede ser cualquier otra especialización), entonces construye un std::move_only_function vacío. De lo contrario, construye un std::move_only_function cuyo objetivo es de tipo VT e inicializado directo-no-lista con std:: forward < F > ( f ) .
  • Esta sobrecarga participa en la resolución de sobrecarga solo si VT no es igual a move_only_function ni una especialización de std::in_place_type_t , y /*is-callable-from*/ < VT > (ver abajo) es true .
  • El programa está mal formado si std:: is_constructible_v < VT, F > no es true .
6) Sea VT igual a std:: decay_t < T > . Construye un std::move_only_function cuyo destino es de tipo VT e inicializado directo-no-lista con std:: forward < CArgs > ( args ) ... .
  • Esta sobrecarga participa en la resolución de sobrecarga solo si tanto std:: is_constructible_v < VT, CArgs... > como /*is-callable-from*/ < VT > (ver abajo) son true .
  • El programa está mal formado si VT no es del mismo tipo que T .
7) Sea VT std:: decay_t < T > . Construye un std::move_only_function cuyo destino es de tipo VT e inicializado directo-no-lista con il, std:: forward < CArgs > ( args ) ... .
  • Esta sobrecarga participa en la resolución de sobrecarga solo si tanto std:: is_constructible_v < VT, std:: initializer_list < U > & , CArgs... > como /*is-callable-from*/ < VT > (ver abajo) son true .
  • El programa está mal formado si VT no es del mismo tipo que T .

Para los constructores (5-7) , el comportamiento es indefinido si VT no satisface los requisitos de Destructible , o si std:: is_move_constructible_v < VT > es true pero VT no satisface los requisitos de MoveConstructible .

La constante /*is-callable-from*/ < VT > depende de cv , ref , y noex en el parámetro de plantilla de std::move_only_function como se muestra a continuación:

cv ref noexcept ( noex ) /*se-puede-llamar-desde*/ < 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... >

Contenidos

Parámetros

other - otro std::move_only_function del cual mover
f - una función u objeto Callable a envolver
args - argumentos para construir el objeto objetivo
il - std::initializer_list para construir el objeto objetivo

Excepciones

5-7) Puede lanzar std::bad_alloc en caso de fallo de asignación o propagar la excepción lanzada por la inicialización del objetivo. No se lanza ninguna excepción si VT es un tipo de puntero a función o una especialización de std::reference_wrapper .

Ejemplo

Esta sección está incompleta
Motivo: sin ejemplo

Véase también

construye una nueva instancia de std::function
(función miembro pública de std::function<R(Args...)> )
construye un nuevo objeto std::copyable_function
(función miembro pública de std::copyable_function )