Quand et comment utiliser les fonctions de rappel en C ?

Fonctions de rappel en C

Quand et comment utiliser les fonctions de rappel :

Fonctions de rappel sont des pointeurs de fonction ou des objets qui sont passés comme arguments à une autre fonction. Ces fonctions de rappel sont ensuite invoquées dans la fonction appelée pour personnaliser son comportement en fonction de la logique de rappel fournie.

Scénarios courants où les fonctions de rappel sont utilisées :

• Écrire du code générique qui peut fonctionner avec une logique différente en acceptant différents rappels.
• Mise en œuvre de systèmes basés sur des événements pour informer les parties intéressées de problèmes spécifiques événements.
• Activation d'un comportement d'exécution dynamique, tel que la modification du comportement d'une certaine action en fonction de la saisie de l'utilisateur.

Types d'appelables en C (11) :

La fonctionnalité de rappel peut être implémentée à l'aide de plusieurs types d'appelables, notamment :

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

Écriture Rappels :

La syntaxe d'écriture des types de rappel diffère selon le type d'appelable utilisé. Voici un aperçu :

1. Pointeurs de fonction :

typedef int (*f_int_t)(int);
int (* foo_p)(int);

2. Pointeurs vers les fonctions des membres :

typedef int (C::* f_C_int_t)(int);
int (C::* C_foo_p)(int);

3. std::Fonction:

std::function<int(int)> stdf_foo = &amp;foo;
std::function<int(const C&, int)> stdf_C_foo = &amp;C::foo;

4. Type de rappel basé sur un modèle :

template<class R, class T>
void stdf_transform_every_int_templ(int * v, unsigned const n, std::function<R(T)> fp)

Appel de rappels :

La syntaxe d'appel des rappels varie en fonction du type de rappel. Voici un aperçu :

1. Pointeurs de fonction :

int b = foobar(a, foo);

2. Pointeurs vers les fonctions des membres :

int b = C_foobar(a, my_c, &C::foo);

3. std::Fonction:

int b = stdf_foobar(a, stdf_foo);

4. Type de rappel basé sur un modèle :

stdf_transform_every_int_templ(&a[0], 5, &foo);

Exemple :

Considérons l'exemple suivant d'une fonction qui transforme chaque entier d'un tableau à l'aide d'un rappel :

void tranform_every_int(int * v, unsigned n, int (*fp)(int))
{
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = fp(v[i]);
  }
}

Cette fonction peut être utilisée avec différentes fonctions de rappel pour obtenir différents behavior :

// Using a function pointer
int double_int(int x) { return 2*x; }
int a[5] = {1, 2, 3, 4, 5};
tranform_every_int(&a[0], 5, double_int); // Transform the array using the double_int callback

// Using lambda expression
tranform_every_int(&a[0], 5, [](int x) -> int { return x/2; }); // Transform the array using an anonymous function that divides each element by 2

// Using std::bind
int nine_x_and_y (int x, int y) { return 9*x + y; }
std::placeholders::_1;
tranform_every_int(&a[0], 5, std::bind(nine_x_and_y, _1, 4)); // Transform the array using std::bind with nine_x_and_y

En conclusion, les fonctions de rappel fournissent un mécanisme puissant et flexible pour personnaliser le comportement des fonctions et permettre un comportement d'exécution dynamique en C . Ils peuvent être implémentés à l'aide de divers callables et leur syntaxe varie en conséquence.

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!