C++ named requirements: Callable

Un type Callable est un type pour lequel les opérations INVOKE et INVOKE<R> (utilisées par, par exemple, std::function , std::bind , et std::thread::thread ) sont applicables.

INVOKE peut être exécuté explicitement en utilisant la fonction de bibliothèque std::invoke .	(depuis C++17)
INVOKE<R> peut être exécuté explicitement en utilisant la fonction de bibliothèque std::invoke_r .	(depuis C++23)

Table des matières 1 Exigences 2 Notes 3 Bibliothèque standard 4 Voir aussi

Exigences

Le type T satisfait Callable si

Étant donné

• f , un objet de type T ,
• ArgTypes , liste appropriée de types d'arguments,
• R , type de retour approprié.

Les expressions suivantes doivent être valides :

Expression	Exigences
INVOKE<R> ( f, std:: declval < ArgTypes > ( ) ... )	L'expression est bien formée dans un contexte non évalué.

Notes

Les pointeurs vers les membres de données sont Callable , même si aucun appel de fonction n'a lieu.

Bibliothèque standard

En outre, les fonctionnalités standards suivantes acceptent tout type Callable (pas seulement les FunctionObject ):

function (C++11)	enveloppe copiable de tout objet appelable copiable (modèle de classe)
move_only_function (C++23)	enveloppe non-copiable de tout objet appelable qui supporte les qualificateurs dans une signature d'appel donnée (modèle de classe)
copyable_function (C++26)	enveloppe copiable de tout objet appelable copiable qui supporte les qualificateurs dans une signature d'appel donnée (modèle de classe)
function_ref (C++26)	enveloppe non-propriétaire de tout objet appelable (modèle de classe)
bind (C++11)	lie un ou plusieurs arguments à un objet fonction (modèle de fonction)
bind_front bind_back (C++20) (C++23)	lie un nombre variable d'arguments, dans l'ordre, à un objet fonction (modèle de fonction)
reference_wrapper (C++11)	CopyConstructible et CopyAssignable enveloppe de référence (modèle de classe)
result_of invoke_result (C++11) (supprimé en C++20) (C++17)	déduit le type de résultat de l'invocation d'un objet appelable avec un ensemble d'arguments (modèle de classe)
thread (C++11)	gère un thread séparé (classe)
jthread (C++20)	std::thread avec support pour l'auto-jointure et l'annulation (classe)
call_once (C++11)	invoque une fonction une seule fois même si appelée depuis plusieurs threads (modèle de fonction)
async (C++11)	exécute une fonction de manière asynchrone (potentiellement dans un nouveau thread) et retourne un std::future qui contiendra le résultat (modèle de fonction)
packaged_task (C++11)	empaquette une fonction pour stocker sa valeur de retour pour une récupération asynchrone (modèle de classe)

Voir aussi

is_invocable is_invocable_r is_nothrow_invocable is_nothrow_invocable_r (C++17)	vérifie si un type peut être invoqué (comme par std::invoke ) avec les types d'arguments donnés (modèle de classe)
invocable regular_invocable (C++20)	spécifie qu'un type appelable peut être invoqué avec un ensemble donné de types d'arguments (concept)
invoke invoke_r (C++17) (C++23)	invoque tout objet Callable avec les arguments donnés et possibilité de spécifier le type de retour (depuis C++23) (modèle de fonction)