std::move_only_function::move_only_function
De fr.cppreference.net
move_only_function() noexcept;
|
(1) | (depuis C++23) |
move_only_function( std::nullptr_t ) noexcept;
|
(2) | (depuis C++23) |
move_only_function( move_only_function&& other ) noexcept;
|
(3) | (depuis C++23) |
move_only_function( const move_only_function& ) = delete;
|
(4) | (depuis C++23) |
template< class F >
move_only_function( F&& f );
|
(5) | (depuis C++23) |
template< class T, class... CArgs >
explicit move_only_function( std::in_place_type_t<T>, CArgs&&... args );
|
(6) | (depuis 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) | (depuis C++23) |
Crée un nouvel std::move_only_function.
1,2) Le constructeur par défaut et le constructeur prenant
nullptr construisent un std::move_only_function vide.3) Le constructeur de déplacement construit un
std::move_only_function dont la cible est celle de other. other est dans un état valide mais non spécifié après la construction par déplacement.4) Le constructeur de copie est supprimé.
std::move_only_function ne satisfait pas CopyConstructible.5) Soit
VT std::decay_t<F>. Si f est un pointeur de fonction nul, un pointeur nul vers un membre de valeur, ou un std::move_only_function vide (il peut s'agir de toute autre spécialisation), alors construit un std::move_only_function vide. Sinon, construit un std::move_only_function dont la cible est de type VT et initialisée par non-liste directe avec std::forward<F>(f).
- Cette surcharge participe à la résolution de surcharge uniquement si
VTn'est ni identique àmove_only_functionni une spécialisation de std::in_place_type_t, et si/*is-callable-from*/<VT>(voir ci-dessous) esttrue. - Le programme est mal formé si
std::is_constructible_v<VT, F>n'est pastrue.
6) Soit
VT std::decay_t<T>. Construit un std::move_only_function dont la cible est de type VT et initialisée par non-liste directe avec std::forward<CArgs>(args)....
- Cette surcharge participe à la résolution de surcharge uniquement si
std::is_constructible_v<VT, CArgs...>et/*is-callable-from*/<VT>(voir ci-dessous) sont tous deuxtrue. - Le programme est mal formé si
VTn'est pas le même type queT.
7) Soit
VT std::decay_t<T>. Construit un std::move_only_function dont la cible est de type VT et initialisée par non-liste directe avec il, std::forward<CArgs>(args)....
- Cette surcharge participe à la résolution de surcharge uniquement si
std::is_constructible_v<VT, std::initializer_list<U>&, CArgs...>et/*is-callable-from*/<VT>(voir ci-dessous) sont tous deuxtrue. - Le programme est mal formé si
VTn'est pas le même type queT.
Pour les constructeurs (5-7), le comportement est indéfini si VT ne satisfait pas les exigences Destructible, ou si std::is_move_constructible_v<VT> est true mais VT ne satisfait pas les exigences MoveConstructible.
La constante /*is-callable-from*/<VT> dépend de cv, ref, et noex dans le paramètre de modèle de std::move_only_function comme ci-dessous :
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...>
|
Paramètres
| other | - |
autre
std::move_only_function
à déplacer
|
| f | - | une fonction ou un objet Callable à encapsuler |
| args | - | arguments pour construire l'objet cible |
| il | - | std::initializer_list pour construire l'objet cible |
Exceptions
5-7)
Peut lever
std::bad_alloc
en cas d'échec d'allocation ou propager l'exception levée par l'initialisation de la cible. Aucune exception n'est levée si
VT
est un type de pointeur de fonction ou une spécialisation de
std::reference_wrapper
.
Exemple
|
Cette section est incomplète
Raison : aucun exemple |
Voir aussi
construit une nouvelle instance
std::function
(fonction membre publique de
std::function<R(Args...)>
)
|
|
construit un nouvel objet
std::copyable_function
(fonction membre publique de
std::copyable_function
)
|