CKTIS / C++
std::function : enveloppe d’appel copiable
std::function stocke tout appelable copiable compatible avec une signature choisie et l’invoque via une interface uniforme.
Version : C++23
Syntaxe
template<class Signature> class std::function;
template<class R, class... Args>
class std::function<R(Args...)> {
public:
function() noexcept;
template<class F> function(F&& f);
explicit operator bool() const noexcept;
R operator()(Args... args) const;
};std::function<R(Args...)> de <functional> est une enveloppe polymorphe à effacement de type. Elle peut contenir pointeur de fonction, foncteur, liaison ou lambda si le type stocké est copiable et invocable avec Args... pour un résultat compatible avec R. L’enveloppe est copiable et déplaçable ; sa copie copie la cible, donc les captures par valeur appartiennent à chaque copie de cible.
L’exemple place une lambda capturant factor par valeur dans std::function<int(int)>. std::function::operator() invoque la cible stockée, donc scale(5) renvoie 15. std::function::operator bool indique si l’enveloppe contient une cible ; la seconde est construite par défaut, donc static_cast<bool>(empty) est faux et le programme affiche 15 0. Testez cet état booléen avant d’appeler un callback facultatif, sauf si le traitement du vide par exception est volontaire.
L’appel d’une enveloppe vide lance std::bad_function_call ; les exceptions de la cible se propagent. La construction peut allouer et lancer std::bad_alloc ou toute exception d’initialisation de la cible, y compris un déplacement lançant depuis un argument rvalue ; l’optimisation des petits objets n’est pas garantie. Une lambda seulement déplaçable ne satisfait pas std::function en C++23 : utilisez std::move_only_function. Une capture par référence ne prolonge pas la durée de vie et peut devenir pendante. target<T>() exige le type stocké exact, et la signature de l’enveloppe ne conserve pas noexcept.
Exemples
#include <functional>
#include <iostream>
int main() {
const int factor = 3;
std::function<int(int)> scale = [factor](int value) {
return factor * value;
};
std::function<int(int)> empty;
std::cout << scale(5) << ' ' << static_cast<bool>(empty) << '\n';
}
Résultat
15 0
std::function → 15 0