Namespaces
Variants

std::copyable_function:: copyable_function

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
std::copyable_function
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 se trouve dans un état valide mais non spécifié après la construction par déplacement.
5) Soit VT défini comme std:: decay_t < F > . Si f est un pointeur de fonction nul, un pointeur nul vers une valeur membre, ou un std::copyable_function vide (peut être toute 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 par direct-non-list-initialization avec std:: forward < F > ( f ) .
6) Soit VT défini comme std:: decay_t < T > . Construit un std::copyable_function dont la cible est de type VT et initialisé par initialisation directe non-liste avec std:: forward < CArgs > ( args ) ... .
  • Cette surcharge participe à la résolution de surcharge seulement si std:: is_constructible_v < VT, CArgs... > et /*is-callable-from*/ < VT > (voir ci-dessous) sont tous deux true .
  • Le programme est malformé si VT n'est pas du même type que T ou si std:: is_copy_constructible_v < VT > n'est pas true .
7) Soit VT défini comme std:: decay_t < T > . Construit un std::copyable_function dont la cible est de type VT et initialisé par initialisation directe non-liste avec il, std:: forward < CArgs > ( args ) ... .

Pour les constructeurs (5-7) , le comportement est indéfini sauf si VT satisfait à 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 suit :

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il contient des termes spécifiques au C++ et se trouve dans des balises ` ` qui doivent être préservées. Seul le texte en dehors de ces balises aurait été traduit si présent. **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises HTML spécifiques et contient des termes techniques C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.
cv ref noexcept ( noex ) /*appelable-depuis*/ < 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... >

Table des matières

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 )