Qu'est-ce qu'un «rappel» en C et comment sont-ils implémentés?
https://stackoverflow.com/questions/142789
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
D'après ce que j'ai lu, Core Audio s'appuie beaucoup sur les rappels (et le C ++, mais c'est une autre histoire).
Je comprends le concept (en quelque sorte) de configuration d’une fonction appelée à plusieurs reprises par une autre fonction pour accomplir une tâche. Je ne comprends tout simplement pas comment ils se sont organisés et comment ils fonctionnent réellement. Tous les exemples seraient appréciés.
La solution
Il n'y a pas de & call; callback " en C - pas plus que tout autre concept de programmation générique.
Ils sont implémentés à l'aide de pointeurs de fonction. Voici un exemple:
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
for (size_t i=0; i<arraySize; i++)
array[i] = getNextValue();
}
int getNextRandomValue(void)
{
return rand();
}
int main(void)
{
int myarray[10];
populate_array(myarray, 10, getNextRandomValue);
...
}
Ici, la fonction populate_array prend un pointeur de fonction en tant que troisième paramètre et l'appelle pour obtenir les valeurs avec lesquelles le tableau doit être rempli. Nous avons écrit le rappel getNextRandomValue , qui renvoie une valeur aléatoire, et nous lui avons passé un pointeur sur populate_array . populate_array appellera notre fonction de rappel 10 fois et affectera les valeurs renvoyées aux éléments du tableau donné.
Autres conseils
Voici un exemple de callback en C.
Supposons que vous souhaitiez écrire un code permettant d’appeler des callbacks lorsqu’un événement se produit.
Définissez d'abord le type de fonction utilisée pour le rappel:
typedef void (*event_cb_t)(const struct event *evt, void *userdata);
Maintenant, définissez une fonction utilisée pour enregistrer un rappel:
int event_cb_register(event_cb_t cb, void *userdata);
Voici à quoi ressemblerait le code qui enregistre un rappel:
static void my_event_cb(const struct event *evt, void *data)
{
/* do stuff and things with the event */
}
...
event_cb_register(my_event_cb, &my_custom_data);
...
Dans les éléments internes du répartiteur d'événements, le rappel peut être stocké dans une structure qui ressemble à ceci:
struct event_cb {
event_cb_t cb;
void *data;
};
Voici à quoi ressemble le code qui exécute un rappel.
struct event_cb *callback;
...
/* Get the event_cb that you want to execute */
callback->cb(event, callback->data);
Un simple programme de rappel. J'espère que cela répond à votre question.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include "../../common_typedef.h"
typedef void (*call_back) (S32, S32);
void test_call_back(S32 a, S32 b)
{
printf("In call back function, a:%d \t b:%d \n", a, b);
}
void call_callback_func(call_back back)
{
S32 a = 5;
S32 b = 7;
back(a, b);
}
S32 main(S32 argc, S8 *argv[])
{
S32 ret = SUCCESS;
call_back back;
back = test_call_back;
call_callback_func(back);
return ret;
}
Une fonction de rappel en C est l'équivalent d'un paramètre / variable de fonction affecté à être utilisé dans une autre fonction. Exemple de wiki
Dans le code ci-dessous,
#include <stdio.h>
#include <stdlib.h>
/* The calling function takes a single callback as a parameter. */
void PrintTwoNumbers(int (*numberSource)(void)) {
printf("%d and %d\n", numberSource(), numberSource());
}
/* A possible callback */
int overNineThousand(void) {
return (rand() % 1000) + 9001;
}
/* Another possible callback. */
int meaningOfLife(void) {
return 42;
}
/* Here we call PrintTwoNumbers() with three different callbacks. */
int main(void) {
PrintTwoNumbers(&rand);
PrintTwoNumbers(&overNineThousand);
PrintTwoNumbers(&meaningOfLife);
return 0;
}
La fonction (* numberSource) de l'appel de fonction PrintTwoNumbers est une fonction permettant de "rappeler". / execute depuis l’intérieur de PrintTwoNumbers comme dicté par le code en cours d’exécution.
Donc, si vous aviez quelque chose comme une fonction pthread, vous pouvez assigner une autre fonction à exécuter dans la boucle à partir de son instanciation.
Les rappels en C sont généralement implémentés à l’aide de pointeurs de fonction et d’un pointeur de données associé. Vous transmettez votre fonction on_event () et des pointeurs de données à une fonction-cadre watch_events () (par exemple). Lorsqu'un événement se produit, votre fonction est appelée avec vos données et des données spécifiques à un événement.
Les rappels sont également utilisés dans la programmation d'interface graphique. Le le didacticiel sur GTK + contient une section intéressante sur le théorie des signaux et des rappels .
Cet article de Wikipédia a un exemple dans C.
Un bon exemple est le fait que les nouveaux modules écrits pour augmenter le serveur Web Apache s’enregistrent avec le processus apache principal en leur transmettant des pointeurs de fonction afin que ces fonctions soient rappelées pour traiter les demandes de page Web.
Un rappel en C est une fonction fournie à une autre fonction pour "rappeler à". à un moment où l'autre fonction accomplit sa tâche.
Il existe deux manières d'utiliser un rappel : rappel synchrone et asynchrone rappeler. Un rappel synchrone est fourni à une autre fonction qui va effectuer une tâche, puis revenir à l'appelant avec la tâche terminée. Un rappel asynchrone est fourni à une autre fonction qui va démarrer une tâche puis revenir à l'appelant avec la tâche éventuellement non terminée.
Un rappel synchrone est généralement utilisé pour fournir un délégué à une autre fonction à laquelle l'autre fonction délègue une étape de la tâche. Les fonctions bsearch () et qsort () de la bibliothèque standard C sont des exemples classiques de cette délégation. Ces deux fonctions reçoivent un rappel utilisé lors de la tâche fournie par la fonction afin que le type des données recherchées, dans le cas de bsearch () , ou trié, dans le cas de < code> qsort () , n'a pas besoin d'être connu par la fonction utilisée.
Voici par exemple un petit exemple de programme avec bsearch () utilisant différentes fonctions de comparaison, des rappels synchrones. En nous permettant de déléguer la comparaison de données à une fonction de rappel, la fonction bsearch () nous permet de décider au moment de l’exécution du type de comparaison que nous souhaitons utiliser. Ceci est synchrone car lorsque la fonction bsearch () renvoie la tâche terminée.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
int iValue;
int kValue;
char label[6];
} MyData;
int cmpMyData_iValue (MyData *item1, MyData *item2)
{
if (item1->iValue < item2->iValue) return -1;
if (item1->iValue > item2->iValue) return 1;
return 0;
}
int cmpMyData_kValue (MyData *item1, MyData *item2)
{
if (item1->kValue < item2->kValue) return -1;
if (item1->kValue > item2->kValue) return 1;
return 0;
}
int cmpMyData_label (MyData *item1, MyData *item2)
{
return strcmp (item1->label, item2->label);
}
void bsearch_results (MyData *srch, MyData *found)
{
if (found) {
printf ("found - iValue = %d, kValue = %d, label = %s\n", found->iValue, found->kValue, found->label);
} else {
printf ("item not found, iValue = %d, kValue = %d, label = %s\n", srch->iValue, srch->kValue, srch->label);
}
}
int main ()
{
MyData dataList[256] = {0};
{
int i;
for (i = 0; i < 20; i++) {
dataList[i].iValue = i + 100;
dataList[i].kValue = i + 1000;
sprintf (dataList[i].label, "%2.2d", i + 10);
}
}
// ... some code then we do a search
{
MyData srchItem = { 105, 1018, "13"};
MyData *foundItem = bsearch (&srchItem, dataList, 20, sizeof(MyData), cmpMyData_iValue );
bsearch_results (&srchItem, foundItem);
foundItem = bsearch (&srchItem, dataList, 20, sizeof(MyData), cmpMyData_kValue );
bsearch_results (&srchItem, foundItem);
foundItem = bsearch (&srchItem, dataList, 20, sizeof(MyData), cmpMyData_label );
bsearch_results (&srchItem, foundItem);
}
}
Un rappel asynchrone est différent en ce sens que lorsque la fonction appelée à laquelle nous fournissons un rappel est renvoyée, la tâche peut ne pas être terminée. Ce type de rappel est souvent utilisé avec les E / S asynchrones dans lesquelles une opération d’E / S est lancée, puis, lorsque celle-ci est terminée, le rappel est appelé.
Dans le programme suivant, nous créons un socket pour écouter les demandes de connexion TCP et lorsqu'une demande est reçue, la fonction effectuant l'écoute appelle ensuite la fonction de rappel fournie. Cette application simple peut être utilisée en l'exécutant dans une fenêtre tout en utilisant l'utilitaire telnet ou un navigateur Web pour tenter de se connecter dans une autre fenêtre.
J'ai extrait la plupart du code WinSock de l'exemple fourni par Microsoft avec la fonction accept () à https://msdn.microsoft.com/en-us/library/windows/desktop/ms737526 (v = vs.85) .aspx
Cette application démarre un listen () sur l'hôte local, 127.0.0.1, via le port 8282 afin que vous puissiez utiliser telnet 127.0.0.1 8282 ou . http://127.0.0.1:8282/ .
Cet exemple d'application a été créé en tant qu'application console avec Visual Studio 2017 Community Edition et utilise la version Microsoft WinSock de sockets. Pour une application Linux, les fonctions WinSock devront être remplacées par les alternatives Linux et la bibliothèque de threads Windows utiliserait plutôt pthreads .
#include <stdio.h>
#include <winsock2.h>
#include <stdlib.h>
#include <string.h>
#include <Windows.h>
// Need to link with Ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")
// function for the thread we are going to start up with _beginthreadex().
// this function/thread will create a listen server waiting for a TCP
// connection request to come into the designated port.
// _stdcall modifier required by _beginthreadex().
int _stdcall ioThread(void (*pOutput)())
{
//----------------------
// Initialize Winsock.
WSADATA wsaData;
int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != NO_ERROR) {
printf("WSAStartup failed with error: %ld\n", iResult);
return 1;
}
//----------------------
// Create a SOCKET for listening for
// incoming connection requests.
SOCKET ListenSocket;
ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (ListenSocket == INVALID_SOCKET) {
wprintf(L"socket failed with error: %ld\n", WSAGetLastError());
WSACleanup();
return 1;
}
//----------------------
// The sockaddr_in structure specifies the address family,
// IP address, and port for the socket that is being bound.
struct sockaddr_in service;
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr("127.0.0.1");
service.sin_port = htons(8282);
if (bind(ListenSocket, (SOCKADDR *)& service, sizeof(service)) == SOCKET_ERROR) {
printf("bind failed with error: %ld\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
//----------------------
// Listen for incoming connection requests.
// on the created socket
if (listen(ListenSocket, 1) == SOCKET_ERROR) {
printf("listen failed with error: %ld\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
//----------------------
// Create a SOCKET for accepting incoming requests.
SOCKET AcceptSocket;
printf("Waiting for client to connect...\n");
//----------------------
// Accept the connection.
AcceptSocket = accept(ListenSocket, NULL, NULL);
if (AcceptSocket == INVALID_SOCKET) {
printf("accept failed with error: %ld\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
else
pOutput (); // we have a connection request so do the callback
// No longer need server socket
closesocket(ListenSocket);
WSACleanup();
return 0;
}
// our callback which is invoked whenever a connection is made.
void printOut(void)
{
printf("connection received.\n");
}
#include <process.h>
int main()
{
// start up our listen server and provide a callback
_beginthreadex(NULL, 0, ioThread, printOut, 0, NULL);
// do other things while waiting for a connection. In this case
// just sleep for a while.
Sleep(30000);
}
Habituellement, cela peut être fait en utilisant un pointeur de fonction, c'est-à-dire une variable spéciale qui pointe vers l'emplacement mémoire d'une fonction. Vous pouvez ensuite l'utiliser pour appeler la fonction avec des arguments spécifiques. Donc, il y aura probablement une fonction qui définit la fonction de rappel. Cela acceptera un pointeur de fonction, puis stockera cette adresse quelque part où elle pourra être utilisée. Ensuite, lorsque l'événement spécifié est déclenché, cette fonction est appelée.
Il est beaucoup plus facile de comprendre une idée grâce à un exemple. Ce qui a été dit à propos de la fonction de rappel en C jusqu’à présent est une excellente réponse, mais le plus grand avantage de l’utilisation de cette fonctionnalité est de garder le code propre et dégagé.
Exemple
Le code C suivant implémente le tri rapide. La ligne la plus intéressante dans le code ci-dessous est celle-ci, où nous pouvons voir la fonction de rappel en action:
qsort(arr,N,sizeof(int),compare_s2b);
compare_s2b est le nom de la fonction que qsort () utilise pour appeler la fonction. Cela permet à qsort () de rester aussi épuré (donc plus facile à maintenir). Vous appelez simplement une fonction par son nom depuis une autre fonction (bien entendu, la déclaration de prototype de fonction, au moins, doit être précisée avant de pouvoir être appelée depuis une autre fonction).
Le code complet
#include <stdio.h>
#include <stdlib.h>
int arr[]={56,90,45,1234,12,3,7,18};
//function prototype declaration
int compare_s2b(const void *a,const void *b);
int compare_b2s(const void *a,const void *b);
//arranges the array number from the smallest to the biggest
int compare_s2b(const void* a, const void* b)
{
const int* p=(const int*)a;
const int* q=(const int*)b;
return *p-*q;
}
//arranges the array number from the biggest to the smallest
int compare_b2s(const void* a, const void* b)
{
const int* p=(const int*)a;
const int* q=(const int*)b;
return *q-*p;
}
int main()
{
printf("Before sorting\n\n");
int N=sizeof(arr)/sizeof(int);
for(int i=0;i<N;i++)
{
printf("%d\t",arr[i]);
}
printf("\n");
qsort(arr,N,sizeof(int),compare_s2b);
printf("\nSorted small to big\n\n");
for(int j=0;j<N;j++)
{
printf("%d\t",arr[j]);
}
qsort(arr,N,sizeof(int),compare_b2s);
printf("\nSorted big to small\n\n");
for(int j=0;j<N;j++)
{
printf("%d\t",arr[j]);
}
exit(0);
}
