std::move_only_function

template< class... >
class move_only_function; // not defined

template< class R, class... Args >
class move_only_function<R(Args...)>;
template< class R, class... Args >
class move_only_function<R(Args...) noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) &>;
template< class R, class... Args >
class move_only_function<R(Args...) & noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) &&>;
template< class R, class... Args >
class move_only_function<R(Args...) && noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) const>;
template< class R, class... Args >
class move_only_function<R(Args...) const noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) const &>;
template< class R, class... Args >
class move_only_function<R(Args...) const & noexcept>;
template< class R, class... Args >
class move_only_function<R(Args...) const &&>;
template< class R, class... Args >
class move_only_function<R(Args...) const && noexcept>;

La plantilla de clase std::move_only_function es un envoltorio polimórfico de funciones de propósito general. std::move_only_function Los objetos pueden almacenar e invocar cualquier destino Invocable 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 destino de std::move_only_function. Si un std::move_only_function no contiene un destino, se denomina vacío. A diferencia de std::function, invocar un vacío std::move_only_function resulta en comportamiento indefinido.

std::move_only_function Los objetos admiten todas las combinaciones posibles de calificadores-cv (sin incluir volatile), calificadores-ref y especificadores-noexcept proporcionados en su parámetro de plantilla. Estos calificadores y especificador (si lo hay) se añaden a su operator().

std::move_only_function satisface los requisitos de MoveConstructible y MoveAssignable, pero no satisface CopyConstructible ni CopyAssignable.

Tipos de miembros

Funciones miembro

Funciones no miembro

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.

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();
}

3.14159

Véase también