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(T)> fp) {
  for (unsigned i = 0; i < n; ++i) {
    v[i] = fp(v[i]);
  }
}

Modèle Rappels :

template<class F>
void transform_every_int_templ(int *v, unsigned const n, F f) {
  for (unsigned i = 0; i < n; ++i) {
    v[i] = f(v[i]);
  }
}

Implémentation du nom de type :

template <class T>
std::string type_name() {
  typedef typename std::remove_reference<T>::type TR;
  std::unique_ptr<char, void(*)(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>::value)
    r += " volatile";
  if (std::is_lvalue_reference<T>::value)
    r += " &amp;&";
  else if (std::is_rvalue_reference<T>::value)
    r += " &amp;&amp;";
  return r;
}

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!