std::function
| Défini dans l'en-tête <functional>
|
||
template< class >
class function; /* undefined */
|
(depuis C++11) | |
template< class R, class... Args >
class function<R(Args...)>;
|
(depuis C++11) | |
Le modèle de classe std::function est un adaptateur de fonction polymorphe à usage général. Les instances de std::function peuvent stocker, copier et invoquer n'importe quel CopyConstructible Callable cible -- des fonctions (via des pointeurs vers celles-ci), des expressions lambda, des expressions bind, ou d'autres objets fonction, ainsi que des pointeurs vers des fonctions membres et des pointeurs vers des données membres.
L'objet appelable stocké est appelé la cible de std::function. Si un std::function ne contient pas de cible, il est dit vide. Invoquer la cible d'un vide std::function lève l'exception std::bad_function_call.
std::function satisfait aux exigences de CopyConstructible et de CopyAssignable.
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 |