Namespaces
Variants

std::move_only_function:: move_only_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::move_only_function
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 nouveau 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 se trouve 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 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::move_only_function vide (peut être 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é par direct-non-list-initialization avec std:: forward < F > ( f ) .
  • Cette surcharge participe à la résolution de surcharge seulement si VT n'est ni identique à move_only_function ni une spécialisation de std::in_place_type_t , et si /*is-callable-from*/ < VT > (voir ci-dessous) est true .
  • Le programme est mal formé si std:: is_constructible_v < VT, F > n'est pas true .
6) Soit VT défini comme std:: decay_t < T > . Construit un std::move_only_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 mal formé si VT n'est pas du même type que T .
7) Soit VT défini comme std:: decay_t < T > . Construit un std::move_only_function dont la cible est de type VT et initialisé par initialisation directe non-liste avec il, std:: forward < CArgs > ( args ) ... .
  • Cette surcharge participe à la résolution de surcharge seulement si std:: is_constructible_v < VT, std:: initializer_list < U > & , CArgs... > et /*is-callable-from*/ < VT > (voir ci-dessous) sont tous deux true .
  • Le programme est mal formé si VT n'est pas du même type que T .

Pour les constructeurs (5-7) , le comportement est indéfini si VT ne satisfait pas aux exigences Destructible , ou si std:: is_move_constructible_v < VT > est true mais que VT ne satisfait pas aux exigences MoveConstructible .

La constante /*is-callable-from*/ < VT > dépend de cv , ref , et noex dans le paramètre template de std::move_only_function comme ci-dessous :

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises HTML et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte en dehors des balises de code aurait été traduit, mais dans cet extrait, tout le contenu est du code C++.
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::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 )