Comment fonctionnent les rappels en C et quelles sont leurs différentes utilisations ?

Les rappels et leurs diverses utilisations en C

En C , un rappel est un appelable (discuté plus tard) accepté par une classe ou une fonction, utilisé pour personnaliser la logique actuelle en fonction du rappel fourni.

Raisons d'utilisation Rappels :

• Pour écrire du code générique indépendant de la logique dans la fonction appelée, permettant sa réutilisation avec différents rappels.
• Pour informer les appelants d'événements spécifiques, en activant la statique et la compilation -flexibilité temporelle.

Que sont les Callables en C ?

• Pointeurs de fonction (y compris les pointeurs vers les fonctions membres)
• std::objets de fonction
• Expressions lambda
• Expressions de liaison
• Objets de fonction (classes avec opérateur d'appel de fonction surchargé Operator())

Écriture et appel de rappels :

Pointeurs de fonction :

• Notation de type : return_type (*)(parameter_type_1, paramètre_type_2, paramètre_type_3)
• Notation d'appel de rappel : function_pointer(argument)
• Notation d'utilisation de rappel : function(argument_list, function_pointer)

Pointeur vers le membre Fonction :

• Notation de type : return_type (class_type::*)(parameter_type_1, paramètre_type_2, paramètre_type_3)
• Notation d'appel de rappel : (class_instance.*member_function_pointer)(argument)
• Callback Utiliser la notation : function(argument_list, class_instance, member_function_pointer)

std::function Objets :

• Type Notation : std::function
• Notation d'appel de rappel : function_object()
• Utilisation du rappel Notation : fonction(argument_list, function_object)

Exemples utilisant std::function:

Code généralisant :

template<class r class t>
void stdf_transform_every_int_templ(int *v, unsigned const n, std::function<r> fp) {
  for (unsigned i = 0; i <p><strong>Modèle Rappels :</strong></p>
<pre class="brush:php;toolbar:false">template<class f>
void transform_every_int_templ(int *v, unsigned const n, F f) {
  for (unsigned i = 0; i <p><strong>Implémentation du nom de type :</strong></p>
<pre class="brush:php;toolbar:false">template <class t>
std::string type_name() {
  typedef typename std::remove_reference<t>::type TR;
  std::unique_ptr<char void> own
    (abi::__cxa_demangle(typeid(TR).name(), nullptr,
    nullptr, nullptr), std::free);
  std::string r = own != nullptr?own.get():typeid(TR).name();
  if (std::is_const<tr>::value)
    r += " const";
  if (std::is_volatile</tr>
<tr>::value)
    r += " volatile";
  if (std::is_lvalue_reference<t>::value)
    r += " &&";
  else if (std::is_rvalue_reference<t>::value)
    r += " &&";
  return r;
}</t></t>
</tr></char></t></class>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!