Una funzione di callback è una funzione, che è un argomento, non un parametro, in un'altra funzione. L'altra funzione può essere chiamata la funzione principale. Quindi sono coinvolte due funzioni: la funzione principale e la funzione di callback stessa. Nell'elenco dei parametri della funzione principale è presente la dichiarazione della funzione di callback senza la sua definizione, così come sono presenti le dichiarazioni di oggetto senza assegnazione. La funzione principale viene chiamata con argomenti (in main()). Uno degli argomenti nella chiamata alla funzione principale è la definizione effettiva della funzione di callback. In C++, questo argomento è un riferimento alla definizione della funzione di callback; non è la definizione reale. La stessa funzione di callback viene effettivamente chiamata all'interno della definizione della funzione principale.
La funzione di callback di base in C++ non garantisce un comportamento asincrono in un programma. Il comportamento asincrono è il vero vantaggio dello schema della funzione di callback. Nello schema della funzione di callback asincrona, il risultato della funzione principale dovrebbe essere ottenuto per il programma prima di ottenere il risultato della funzione di callback. È possibile farlo in C++; tuttavia, C++ ha una libreria chiamata future per garantire il comportamento dello schema della funzione di callback asincrona.
Questo articolo spiega lo schema di base della funzione di callback. Molto è con C pure puro++. Per quanto riguarda il callback viene spiegato anche il comportamento di base della futura libreria. La conoscenza di base del C++ e dei suoi puntatori è necessaria per la comprensione di questo articolo.
Contenuto dell'articolo
- Schema della funzione di richiamata di base
- Comportamento sincrono con funzione di callback
- Comportamento asincrono con funzione di callback
- Uso di base della futura Biblioteca
- Conclusione
Schema della funzione di richiamata di base
Uno schema di funzione di callback necessita di una funzione principale e della stessa funzione di callback. La dichiarazione della funzione di callback fa parte dell'elenco dei parametri della funzione principale. La definizione della funzione di callback è indicata nella chiamata di funzione della funzione principale. La funzione di callback viene effettivamente chiamata all'interno della definizione della funzione principale. Il seguente programma lo illustra:
#includereusando lo spazio dei nomi std;
int principalFn(char ch[], int (*ptr)(int))
int id1 = 1;
int id2 = 2;
int idr = (*ptr)(id2);
cout<<"principal function: "<
int cb(int iden)
cout<<"callback function"<<'\n';
restituire l'identità;
intero principale()
int (*ptr)(int) = &cb;
char cha[] = "e";
principaleFn(cha, cb);
restituisce 0;
L'uscita è:
funzione di richiamatafunzione principale: 1 e 2
La funzione principale è identificata da principalFn(). La funzione di callback è identificata da cb(). La funzione di callback è definita al di fuori della funzione principale ma in realtà chiamata all'interno della funzione principale principal.
Notare la dichiarazione della funzione di callback come parametro nell'elenco dei parametri della dichiarazione della funzione principale. La dichiarazione della funzione di callback è "int (*ptr)(int)". Notare l'espressione della funzione di callback, come una chiamata di funzione, nella definizione della funzione principale; qualsiasi argomento per la chiamata alla funzione di callback viene passato lì. L'istruzione per questa chiamata di funzione è:
int idr = (*ptr)(id2);Dove id2 è un argomento. ptr fa parte del parametro, un puntatore, che sarà collegato al riferimento della funzione di callback nella funzione main().
Notare l'espressione:
int (*ptr)(int) = &cb;Nella funzione main(), che collega la dichiarazione (senza definizione) della funzione di callback al nome della definizione della stessa funzione di callback.
La funzione principale è chiamata, nella funzione main(), come:
principaleFn(cha, cb);Dove cha è una stringa e cb è il nome della funzione di callback senza nessuno dei suoi argomenti.
Comportamento sincrono della funzione di callback
Considera il seguente programma:
#includereusando lo spazio dei nomi std;
void principalFn(void (*ptr)())
cout<<"principal function"<<'\n';
(*ptr)();
vuoto cb()
cout<<"callback function"<<'\n';
vuoto fn()
cout<<"seen"<<'\n';
intero principale()
void (*ptr)() = &cb;
principaleFn(cb);
fn();
restituisce 0;
L'uscita è:
funzione principalefunzione di richiamata
visto
C'è una nuova funzione qui. Tutto ciò che fa la nuova funzione è visualizzare l'output, "visto". Nella funzione main(), viene chiamata la funzione principale, quindi viene chiamata la nuova funzione, fn(). L'output mostra che è stato eseguito il codice per la funzione principale, poi quello per la funzione di callback e infine quello per la funzione fn(). Questo è un comportamento sincrono (a thread singolo).
Se si trattasse di un comportamento asincrono, quando vengono chiamati tre code segment in ordine, potrebbe essere eseguito il primo code segment, seguito invece dall'esecuzione del terzo code segment, prima che venga eseguito il secondo code segment.
Bene, la funzione fn() può essere chiamata dall'interno della definizione della funzione principale, invece che dall'interno della funzione main(), come segue:
#includereusando lo spazio dei nomi std;
vuoto fn()
cout<<"seen"<<'\n';
void principalFn(void (*ptr)())
cout<<"principal function"<<'\n';
fn();
(*ptr)();
vuoto cb()
cout<<"callback function"<<'\n';
intero principale()
void (*ptr)() = &cb;
principaleFn(cb);
restituisce 0;
L'uscita è:
funzione principalevisto
funzione di richiamata
Questa è un'imitazione del comportamento asincrono. Non è un comportamento asincrono. È ancora un comportamento sincrono.
Inoltre, l'ordine di esecuzione del segmento di codice della funzione principale e del segmento di codice della funzione di callback può essere scambiato nella definizione della funzione principale. Il seguente programma lo illustra:
#includereusando lo spazio dei nomi std;
void principalFn(void (*ptr)())
(*ptr)();
cout<<"principal function"<<'\n';
vuoto cb()
cout<<"callback function"<<'\n';
vuoto fn()
cout<<"seen"<<'\n';
intero principale()
void (*ptr)() = &cb;
principaleFn(cb);
fn();
restituisce 0;
L'output è ora,
funzione di richiamatafunzione principale
visto
Anche questa è un'imitazione del comportamento asincrono. Non è un comportamento asincrono. È ancora un comportamento sincrono. Il vero comportamento asincrono può essere ottenuto come spiegato nella sezione successiva o con la libreria, future.
Comportamento asincrono con funzione di callback
Lo pseudo-codice per lo schema della funzione di callback asincrono di base è:
tipo di uscita;tipo cb (tipo output)
//dichiarazioni
tipo principalFn (tipo input, tipo cb (tipo output))
//dichiarazioni
Annotare le posizioni dei dati di input e output nei diversi luoghi dello pseudo-codice. L'input della funzione di callback è il suo output. I parametri della funzione principale sono il parametro di input per il codice generale e il parametro per la funzione di callback. Con questo schema, una terza funzione può essere eseguita (chiamata) nella funzione main() prima che venga letto l'output della funzione callback (sempre nella funzione main()). Il codice seguente lo illustra:
#includereusando lo spazio dei nomi std;
carattere *output;
void cb(char out[])
uscita = uscita;
void principalFn(char input[], void (*ptr)(char[50]))
(*ptr)(ingresso);
cout<<"principal function"<<'\n';
vuoto fn()
cout<<"seen"<<'\n';
intero principale()
char input[] = "funzione di richiamata";
void (*ptr)(char[]) = &cb;
principaleFn(ingresso, cb);
fn();
cout<