std::copyable_function :: copyable_function
Depuis fr.cppreference.net
copyable_function() noexcept;
|
(1) | (depuis C++26) |
copyable_function( std::nullptr_t ) noexcept;
|
(2) | (depuis C++26) |
copyable_function( const copyable_function& other );
|
(3) | (depuis C++26) |
copyable_function( copyable_function&& other ) noexcept;
|
(4) | (depuis C++26) |
template< class F >
copyable_function( F&& f );
|
(5) | (depuis C++26) |
template< class T, class... CArgs >
explicit copyable_function( std::in_place_type_t<T>, CArgs&&... args );
|
(6) | (depuis C++26) |
template< class T, class U, class... CArgs >
explicit copyable_function( std::in_place_type_t<T>,
std::initializer_list<U> il, CArgs&&... args );
|
(7) | (depuis C++26) |
Crée un nouveau std::copyable_function.
1,2) Le constructeur par défaut et le constructeur prenant
nullptr construisent un std::copyable_function vide.3) Le constructeur de copie construit un
std::copyable_function dont la cible est une copie de la cible de other. Sinon, construit un std::copyable_function vide si other est vide.4) Le constructeur de déplacement construit un
std::copyable_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.5) Soit
VT égal à std::decay_t<F>. Si f est un pointeur de fonction nul, une valeur nulle de pointeur vers membre, ou un std::copyable_function vide (il peut s'agir de n'importe quelle autre spécialisation), alors construit un std::copyable_function vide. Sinon, construit un std::copyable_function dont la cible est de type VT et initialisée directement sans liste avec std::forward<F>(f).
- Cette surcharge participe à la résolution de surcharge uniquement si
VTn'est ni identique àcopyable_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>oustd::is_copy_constructible_v<VT>n'est pastrue.
6) Soit
VT égal à std::decay_t<T>. Construit un std::copyable_function dont la cible est de type VT et initialisée directement sans liste avec std::forward<CArgs>(args)....
- Cette surcharge participe à la résolution de surcharge uniquement si à la fois
std::is_constructible_v<VT, CArgs...>et/*is-callable-from*/<VT>(voir ci-dessous) sonttrue. - Le programme est mal formé si
VTn'est pas le même type queTou sistd::is_copy_constructible_v<VT>n'est pastrue.
7) Soit
VT égal à std::decay_t<T>. Construit un std::copyable_function dont la cible est de type VT et initialisée directement sans liste avec il, std::forward<CArgs>(args)....
- Cette surcharge participe à la résolution de surcharge uniquement si à la fois
std::is_constructible_v<VT, std::initializer_list<U>&, CArgs...>et/*is-callable-from*/<VT>(voir ci-dessous) sonttrue. - Le programme est mal formé si
VTn'est pas le même type queTou sistd::is_copy_constructible_v<VT>n'est pastrue.
Pour les constructeurs (5-7), le comportement est indéfini à moins que VT ne satisfasse à la fois aux exigences Destructible et CopyConstructible.
La constante /*is-callable-from*/<VT> dépend de cv, ref, et noex dans le paramètre template de std::copyable_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::copyable_function
à copier ou déplacer
|
| f | - | fonction ou objet Callable à encapsuler |
| args | - | arguments pour construire l'objet cible |
| il | - | std::initializer_list pour construire l'objet cible |
Exceptions
3)
Peut lever
std::bad_alloc
en cas d'échec d'allocation ou propager l'exception levée par l'initialisation de la cible.
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::move_only_function
(fonction membre publique de
std::move_only_function
)
|