std::move_only_function::move_only_function
De es.cppreference.net
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 destino es el de other. other está en un estado válido pero no especificado después de la construcción por movimiento.5) Sea
VT 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 destino 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
VTno es ni igual amove_only_functionni una especialización de std::in_place_type_t, y/*is-callable-from*/<VT>(ver abajo) estrue. - El programa está mal formado si
std::is_constructible_v<VT, F>no estrue.
6) Sea
VT 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) sontrue. - El programa está mal formado si
VTno es el mismo tipo queT.
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) sontrue. - El programa está mal formado si
VTno es el mismo tipo queT.
Para los constructores (5-7), el comportamiento no está definido si VT no satisface los requisitos de Destructible, o 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 indica a continuación:
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...>
|
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
)
|