Funzione di callback in C++

Callback Function C

Una funzione di callback è una funzione, che è un argomento, non un parametro, in un'altra funzione. L'altra funzione può essere chiamata funzione principale. Quindi sono coinvolte due funzioni: la funzione principale e la stessa funzione di callback. 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 della funzione di callback di base. Molto è con C++ 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

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:



#includere

usando spazio dei nomiore;



intmainFn(charch[],int (*ptr)(int))

{

intid1= 1;

intid2= 2;

intgeneralmente= (*ptr)(id2);

costo<<'funzione principale: '<<id1<<''<<ch<<''<<generalmente<<' ';

Restituzioneid1;

}


intcb(intidentità)

{

costo<<'funzione di richiamata'<<' ';

Restituzioneidentità;

}


intprincipale()

{

int (*ptr)(int) = &cb;

charno[] = 'e';

mainFn(padre, cb);



Restituzione 0;

}

L'uscita è:

funzione di richiamata

funzione principale: 1 e 2

La funzione principale è identificata da principalFn(). La funzione di callback è identificata da cb(). La funzione di callback è definita all'esterno della funzione principale ma effettivamente chiamata all'interno della funzione principale.

Prendere nota della 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 è:



intgeneralmente= (*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:

mainFn(padre, 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:

#includere

usando spazio dei nomiore;



vuotomainFn(vuoto (*ptr)())

{

costo<<'funzione principale'<<' ';

(*ptr)();

}


vuotocb()

{

costo<<'funzione di richiamata'<<' ';

}


vuotofn()

{

costo<<'visto'<<' ';

}


intprincipale()

{

vuoto (*ptr)() = &cb;

mainFn(cb);

fn();



Restituzione 0;

}

L'uscita è:

funzione principale

funzione 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, quindi è stato eseguito quello per la funzione di callback e infine è stato eseguito quello per la funzione fn(). Questo è un comportamento sincrono (a thread singolo).

Se si trattasse di un comportamento asincrono, quando vengono chiamati tre segmenti di codice in ordine, potrebbe essere eseguito il primo segmento di codice, seguito invece dall'esecuzione del terzo segmento di codice, prima che venga eseguito il secondo segmento di codice.

Bene, la funzione fn() può essere chiamata dall'interno della definizione della funzione principale, invece che dall'interno della funzione main(), come segue:

#includere

usando spazio dei nomiore;



vuotofn()

{

costo<<'visto'<<' ';

}


vuotomainFn(vuoto (*ptr)())

{

costo<<'funzione principale'<<' ';

fn();

(*ptr)();

}


vuotocb()

{

costo<<'funzione di richiamata'<<' ';

}


intprincipale()

{

vuoto (*ptr)() = &cb;

mainFn(cb);



Restituzione 0;

}

L'uscita è:

funzione principale

visto

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:

#includere

usando spazio dei nomiore;



vuotomainFn(vuoto (*ptr)())

{

(*ptr)();

costo<<'funzione principale'<<' ';

}


vuotocb()

{

costo<<'funzione di richiamata'<<' ';

}


vuotofn()

{

costo<<'visto'<<' ';

}


intprincipale()

{

vuoto (*ptr)() = &cb;

mainFn(cb);

fn();



Restituzione 0;

}

L'uscita è ora,

funzione di richiamata

funzione 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 di uscita)

{

//dichiarazioni

}


tipo principalFn(digitare input, digitare cb(tipo di uscita))

{

//dichiarazioni

}

Annotare le posizioni dei dati di input e output nei diversi punti 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:

#includere

usando spazio dei nomiore;

char *produzione;


vuotocb(charfuori[])

{

produzione=fuori;

}



vuotomainFn(charingresso[],vuoto (*ptr)(char[cinquanta]))

{

(*ptr)(ingresso);

costo<<'funzione principale'<<' ';

}


vuotofn()

{

costo<<'visto'<<' ';

}


intprincipale()

{

charingresso[] = 'funzione di richiamata';

vuoto (*ptr)(char[]) = &cb;

mainFn(ingresso, cb);

fn();

costo<<produzione<<' ';



Restituzione 0;

}

L'output del programma è:

funzione principale

visto

funzione di richiamata

In questo particolare codice, il dato di output e di input sembra essere lo stesso dato. Il risultato della terza chiamata di funzione nella funzione main() è stato visualizzato prima del risultato della funzione di callback. La funzione di callback ha eseguito, terminato e assegnato il suo risultato (valore) alla variabile output, consentendo al programma di continuare senza la sua interferenza. Nella funzione main(), l'output della funzione di callback è stato utilizzato (letto e visualizzato) quando era necessario, portando a un comportamento asincrono per l'intero schema.

Questo è il modo a thread singolo per ottenere il comportamento asincrono della funzione di callback con C++ puro.

Uso di base della futura Biblioteca

L'idea dello schema della funzione di callback asincrona è che la funzione principale viene restituita prima del ritorno della funzione di callback. Ciò è stato fatto indirettamente, in modo efficace, nel codice di cui sopra.

Si noti dal codice precedente che la funzione di callback riceve l'input principale per il codice e produce l'output principale per il codice. La libreria C++, futura, ha una funzione chiamata sync(). Il primo argomento di questa funzione è il riferimento alla funzione di callback; il secondo argomento è l'input per la funzione di callback. La funzione sync() ritorna senza attendere il completamento dell'esecuzione della funzione di callback, ma consente il completamento della funzione di callback. Ciò fornisce un comportamento asincrono. Mentre la funzione di callback continua ad essere eseguita, poiché la funzione sync() è già stata restituita, le istruzioni sottostanti continuano ad essere eseguite. Questo è come un comportamento asincrono ideale.

Il programma di cui sopra è stato riscritto di seguito, prendendo in considerazione la futura libreria e la sua funzione sync():

#includere

#includere

#includere

usando spazio dei nomiore;

futuro<corda>produzione;

stringa cb(stringa stri)

{

Restituzionestri;

}



vuotomainFn(input stringa)

{

produzione=asincrono(cb, ingresso);

costo<<'funzione principale'<<' ';

}


vuotofn()

{

costo<<'visto'<<' ';

}


intprincipale()

{

input stringa=corda('funzione di richiamata');

mainFn(ingresso);

fn();

stringa ret=produzione.ottenere(); // attende il ritorno della richiamata se necessario

costo<<Giusto<<' ';



Restituzione 0;

}

La funzione sync() infine memorizza l'output della funzione di callback nell'oggetto futuro. L'output previsto può essere ottenuto nella funzione main(), utilizzando la funzione membro get() dell'oggetto futuro.

Conclusione

Una funzione di callback è una funzione, che è un argomento, non un parametro, in un'altra funzione. 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 (in main()). La funzione di callback viene effettivamente chiamata all'interno della definizione della funzione principale.

Uno schema di funzione di callback non è necessariamente asincrono. Per essere sicuri che lo schema della funzione di callback sia asincrono, inserire l'input principale nel codice, l'input nella funzione di callback; rendere l'output principale del codice, l'output della funzione di callback; memorizzare l'output della funzione di callback in una variabile o in una struttura dati. Nella funzione main(), dopo aver chiamato la funzione principale, esegue altre istruzioni dell'applicazione. Quando è necessario l'output della funzione di callback, nella funzione main(), usalo (leggi e visualizza) lì e poi.