std:: function
|
Défini dans l'en-tête
<functional>
|
||
|
template
<
class
>
class function ; /* non défini */ |
(depuis C++11) | |
|
template
<
class
R,
class
...
Args
>
class function < R ( Args... ) > ; |
(depuis C++11) | |
Le modèle de classe
std::function
est un wrapper de fonction polymorphe à usage général. Les instances de
std::function
peuvent stocker, copier et invoquer toute
CopyConstructible
Callable
cible
-- fonctions (via des pointeurs vers celles-ci),
expressions lambda
,
expressions de liaison
, ou autres objets fonction, ainsi que des pointeurs vers des fonctions membres et des pointeurs vers des membres de données.
L'objet appelable stocké est appelé la
cible
de
std::function
. Si une
std::function
ne contient pas de cible, elle est dite
vide
. L'invocation de la
cible
d'une
vide
std::function
entraîne la levée de l'exception
std::bad_function_call
.
std::function
satisfait les exigences de
CopyConstructible
et
CopyAssignable
.
Table des matières |
Types membres
| Type | Définition |
result_type
|
R
|
argument_type
(obsolète en C++17) (supprimé en C++20) |
T
si
sizeof...
(
Args
)
==
1
et
T
est le premier et unique type dans
Args...
|
first_argument_type
(obsolète en C++17) (supprimé en C++20) |
T1
si
sizeof...
(
Args
)
==
2
et
T1
est le premier des deux types dans
Args...
|
second_argument_type
(obsolète en C++17) (supprimé en C++20) |
T2
si
sizeof...
(
Args
)
==
2
et
T2
est le second des deux types dans
Args...
|
Fonctions membres
construit une nouvelle instance de
std::function
(fonction membre publique) |
|
détruit une instance de
std::function
(fonction membre publique) |
|
|
assigne une nouvelle cible
(fonction membre publique) |
|
|
échange le contenu
(fonction membre publique) |
|
|
(supprimé en C++17)
|
assigne une nouvelle cible
(fonction membre publique) |
|
vérifie si une cible est contenue
(fonction membre publique) |
|
|
invoque la cible
(fonction membre publique) |
|
Accès à la cible |
|
|
obtient le
typeid
de la cible stockée
(fonction membre publique) |
|
|
obtient un pointeur vers la cible stockée
(fonction membre publique) |
|
Fonctions non membres
|
(C++11)
|
spécialise l'algorithme
std::swap
(modèle de fonction) |
|
(supprimé en C++20)
|
compare un
std::function
avec
nullptr
(modèle de fonction) |
Classes d'assistance
|
(C++11)
(jusqu'à C++17)
|
spécialise le
std::uses_allocator
trait de type
(spécialisation de modèle de classe) |
Guides de déduction (depuis C++17)
Notes
|
Il convient de faire preuve de prudence lorsqu'un
|
(jusqu'à C++23) |
|
Si un
|
(depuis C++23) |
std::function<const int&()> F([] { return 42; }); // Erreur depuis C++23 : impossible de lier // la référence retournée à un temporaire int x = F(); // Comportement indéfini jusqu'à C++23 : le résultat de F() est une référence pendante std::function<int&()> G([]() -> int& { static int i{0x2A}; return i; }); // OK std::function<const int&()> H([i{052}] -> const int& { return i; }); // OK
Exemple
#include <functional> #include <iostream> struct Foo { Foo(int num) : num_(num) {} void print_add(int i) const { std::cout << num_ + i << '\n'; } int num_; }; void print_num(int i) { std::cout << i << '\n'; } struct PrintNum { void operator()(int i) const { std::cout << i << '\n'; } }; int main() { // stocker une fonction libre std::function<void(int)> f_display = print_num; f_display(-9); // stocker une lambda std::function<void()> f_display_42 = []() { print_num(42); }; f_display_42(); // stocker le résultat d'un appel à std::bind std::function<void()> f_display_31337 = std::bind(print_num, 31337); f_display_31337(); // stocker un appel à une fonction membre std::function<void(const Foo&, int)> f_add_display = &Foo::print_add; const Foo foo(314159); f_add_display(foo, 1); f_add_display(314159, 1); // stocker un appel à un accesseur de membre de données std::function<int(Foo const&)> f_num = &Foo::num_; std::cout << "num_: " << f_num(foo) << '\n'; // stocker un appel à une fonction membre et un objet using std::placeholders::_1; std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1); f_add_display2(2); // stocker un appel à une fonction membre et un pointeur d'objet std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1); f_add_display3(3); // stocker un appel à un objet fonction std::function<void(int)> f_display_obj = PrintNum(); f_display_obj(18); auto factorial = [](int n) { // stocker un objet lambda pour émuler un "lambda récursif" ; conscient du surcoût supplémentaire std::function<int(int)> fac = [&](int n) { return (n < 2) ? 1 : n * fac(n - 1); }; // noter que "auto fac = [&](int n) {...};" ne fonctionne pas dans les appels récursifs return fac(n); }; for (int i{5}; i != 8; ++i) std::cout << i << "! = " << factorial(i) << "; "; std::cout << '\n'; }
Sortie possible :
-9 42 31337 314160 314160 num_: 314159 314161 314162 18 5! = 120; 6! = 720; 7! = 5040;
` n'a pas été traduit car il contient des valeurs numériques, des identifiants de variables et des expressions mathématiques qui doivent rester inchangés selon les consignes de traduction.
Voir aussi
|
(C++23)
|
wrapper non-copiable de tout objet appelable qui prend en charge les qualificateurs dans une signature d'appel donnée
(modèle de classe) |
|
(C++26)
|
wrapper copiable de tout objet appelable constructible par copie qui prend en charge les qualificateurs dans une signature d'appel donnée
(modèle de classe) |
|
(C++26)
|
wrapper non propriétaire de tout objet appelable
(modèle de classe) |
|
(C++11)
|
l'exception levée lors de l'appel d'un
std::function
vide
(classe) |
|
(C++11)
|
crée un objet fonction à partir d'un pointeur vers un membre
(modèle de fonction) |
| typeid | interroge les informations d'un type, renvoyant un objet std::type_info représentant le type |