Qu'est ce qu'un “rappel” en C et comment sont-ils mis en œuvre?

Il n'y a pas de "rappel" en C - pas plus que toute autre programmation générique concept.

Ils sont mis en œuvre en utilisant des 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, le populate_array fonction prend un pointeur de fonction en tant que troisième paramètre, et l'appelle pour obtenir les valeurs pour remplir le tableau avec. Nous avons écrit le rappel getNextRandomValue, qui renvoie un hasard-ish valeur, et passé un pointeur à populate_array. populate_array appelle notre fonction de rappel 10 fois et attribuer les valeurs renvoyées aux éléments dans le tableau donné.

Un simple retour d'appel du programme. Espère que ça 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;
}

Rappels de C sont généralement mises en œuvre à l'aide de pointeurs de fonction et d'un pointeur de données. Vous passez votre fonction on_event() et les pointeurs de données à un cadre de la fonction watch_events() (par exemple). Lorsqu'un événement se produit, votre fonction est appelée avec vos données et les données spécifiques aux événements.

Rappels sont également utilisés dans la programmation GUI. Le GTK+ tutoriel a une belle section sur la la théorie des signaux et des rappels.

Un rappel C est une fonction qui est fourni à une autre fonction de "rappel" à un moment donné de l'autre fonction est de faire de sa tâche.

Il y a deux moyens qu'un rappel est utilisé: synchrone de rappel et rappel asynchrone. Synchrone de rappel est fourni à une autre fonction qui va faire une tâche, puis retour à l'appelant avec la tâche à accomplir. Un rappel asynchrone est fourni à une autre fonction qui va démarrer une tâche, puis retour à l'appelant avec la tâche peut-être pas terminé.

Synchrone de rappel est généralement utilisé pour fournir un délégué d'une autre fonction pour laquelle l'autre fonction délègue une partie de l'étape de la tâche. Des exemples classiques de cette délégation sont les fonctions bsearch() et qsort() de la Bibliothèque C Standard. Ces deux fonctions prennent un rappel qui est utilisé au cours de la tâche, la fonction est de fournir, de sorte que le type de données recherchées, dans le cas de bsearch(), ou triées, dans le cas de qsort(), n'a pas besoin d'être connu par la fonction en cours d'utilisation.

Par exemple, ici est un petit exemple de programme avec bsearch() à l'aide de différentes fonctions de comparaison, synchrone rappels. En ce qui nous permet de déléguer la comparaison des données à une fonction de rappel, le bsearch() fonction nous permet de décider au moment de l'exécution de ce genre de comparaison que nous voulons utiliser. C'est synchrone, car lorsque le bsearch() fonction renvoie la tâche est 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 que lorsque la fonction appelée à qui nous fournissons un callback retourne, la tâche peut ne pas être terminé. Ce type de callback est souvent utilisé avec des I/O asynchrone dans lequel une opération d'e/S est de commencer et puis quand il est terminé, la fonction de rappel est appelée.

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 de faire de l'écoute puis appelle la fonction de rappel prévue. Cette application simple peut être exercé en l'exécutant dans une fenêtre lors de l'utilisation du telnet utilitaire ou un navigateur web pour essayer de vous connecter dans une autre fenêtre.

J'ai levé la plupart des WinSock code à partir de l'exemple de Microsoft fournit avec le accept() fonction à 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, en utilisant le port 8282 de sorte que vous pourriez utiliser telnet 127.0.0.1 8282 ou http://127.0.0.1:8282/.

Cet exemple d'application a été créé comme une application de console Visual Studio 2017 Community Edition et c'est à l'aide de Microsoft WinSock version de sockets. Pour une application Linux WinSock fonctions devra être remplacé avec le Linux solutions de rechange et les threads Windows, bibliothèque de l'utilisation pthreads à la place.

#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);
}

Il est beaucoup plus facile de comprendre une idée par exemple.
Ce qui a été dit sur la fonction de rappel dans C jusqu'à présent sont d'excellentes réponses, mais probablement le plus grand avantage de l'utilisation de la fonctionnalité est pour avoir un code propre et bien rangé.

Exemple

Suivants du code C implémente le tri rapide.
La ligne la plus intéressante dans le code ci-dessous est celui-ci, où l'on peut voir la fonction de rappel dans l'action:

qsort(arr,N,sizeof(int),compare_s2b);

La compare_s2b est le nom de la fonction qsort() pour appeler la fonction. Cela permet de maintenir qsort() de façon aérée (donc plus facile à entretenir). Vous venez d'appeler une fonction par nom à partir de l'intérieur d'une autre fonction (bien sûr, le prototype de fonction de la déclaration, au moins, doivent precde avant elle peut être appelée à partir d'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);
}