std:: move_only_function
|
Definido en el encabezado
<functional>
|
||
|
template
<
class
...
>
class move_only_function ; // no definido |
(1) | (desde C++23) |
|
template
<
class
R,
class
...
Args
>
class
move_only_function
<
R
(
Args...
)
>
;
|
(2) | (desde C++23) |
La plantilla de clase
std::move_only_function
es un contenedor de funciones polimórfico de propósito general.
Los objetos
std::move_only_function
pueden almacenar e invocar cualquier
Callable
target
construible (no se requiere que sea construible por movimiento)
— funciones,
expresiones lambda
,
expresiones bind
, u otros objetos función, así como punteros a funciones miembro y punteros a objetos miembro.
El objeto invocable almacenado se denomina
target
de
std::move_only_function
. Si un
std::move_only_function
no contiene ningún target, se denomina
empty
. A diferencia de
std::function
, invocar un
empty
std::move_only_function
resulta en comportamiento indefinido.
std::move_only_function
admite todas las combinaciones posibles de
cv-qualifiers
(excluyendo
volatile
),
ref-qualifiers
, y
noexcept-specifiers
proporcionadas en su parámetro de plantilla. Estos calificadores y especificadores (si los hay) se añaden a su
operator()
.
std::move_only_function
satisface los requisitos de
MoveConstructible
y
MoveAssignable
, pero no satisface
CopyConstructible
ni
CopyAssignable
.
Contenidos |
Tipos de miembros
| Tipo | Definición |
result_type
|
R
|
Funciones miembro
construye un nuevo objeto
std::move_only_function
(función miembro pública) |
|
destruye un objeto
std::move_only_function
(función miembro pública) |
|
|
reemplaza o destruye el objetivo
(función miembro pública) |
|
intercambia los objetivos de dos objetos
std::move_only_function
(función miembro pública) |
|
verifica si el
std::move_only_function
tiene un objetivo
(función miembro pública) |
|
|
invoca el objetivo
(función miembro pública) |
Funciones no miembro
|
(C++23)
|
especializa el algoritmo
std::swap
(función) |
|
(C++23)
|
compara un
std::move_only_function
con
nullptr
(función) |
Notas
Las implementaciones pueden almacenar un objeto invocable de tamaño pequeño dentro del
std::move_only_function
objeto. Esta optimización de objeto pequeño está efectivamente requerida para punteros a función y
std::reference_wrapper
especializaciones, y solo puede aplicarse a tipos
T
para los cuales
std::
is_nothrow_move_constructible_v
<
T
>
es
true
.
Si un
std::move_only_function
que retorna una referencia se inicializa desde una función u objeto función que retorna un prvalue (incluyendo una expresión lambda sin un tipo-de-retorno-final), el programa está mal formado porque enlazar la referencia retornada a un objeto temporal está prohibido. Véase también
std::function
Notas.
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_move_only_function
|
202110L
|
(C++23) |
std::move_only_function
|
Ejemplo
#include <functional> #include <future> #include <iostream> int main() { std::packaged_task<double()> packaged_task([](){ return 3.14159; }); std::future<double> future = packaged_task.get_future(); auto lambda = [task = std::move(packaged_task)]() mutable { task(); }; // std::function<void()> function = std::move(lambda); // Error std::move_only_function<void()> function = std::move(lambda); // OK function(); std::cout << future.get(); }
Salida:
3.14159
Véase también
|
(C++11)
|
envoltorio copiable de cualquier objeto invocable copiable
(plantilla de clase) |
|
(C++26)
|
envoltorio no propietario de cualquier objeto invocable
(plantilla de clase) |
|
(C++26)
|
envoltorio copiable de cualquier objeto invocable copiable que soporta calificadores en una firma de llamada dada
(plantilla de clase) |