Callback-funktion i C ++

En tilbagekaldsfunktion er en funktion, der er et argument, ikke en parameter, i en anden funktion. Den anden funktion kan kaldes hovedfunktionen. Så to funktioner er involveret: hovedfunktionen og selve tilbagekaldsfunktionen. I parameterlisten over hovedfunktionen er erklæringen om tilbagekaldsfunktionen uden dens definition til stede, ligesom objektdeklarationer uden tildeling er til stede. Hovedfunktionen kaldes med argumenter (i main ()). Et af argumenterne i hovedfunktionsopkaldet er den effektive definition af tilbagekaldsfunktionen. I C ++ er dette argument en henvisning til definitionen af tilbagekaldsfunktionen; det er ikke den egentlige definition. Selve tilbagekaldsfunktionen kaldes faktisk inden for definitionen af hovedfunktionen.

Den grundlæggende tilbagekaldsfunktion i C ++ garanterer ikke asynkron opførsel i et program. Asynkron opførsel er den reelle fordel ved tilbagekaldsfunktionsordningen. I det asynkrone tilbagekaldsfunktionsskema skal resultatet af hovedfunktionen opnås for programmet, før resultatet af tilbagekaldsfunktionen opnås. Det er muligt at gøre dette i C ++; C ++ har dog et bibliotek kaldet fremtid for at garantere opførelsen af den asynkrone tilbagekaldsfunktionsplan.

Denne artikel forklarer det grundlæggende system til tilbagekaldsfunktion. Meget af det er med ren C++. For så vidt angår tilbagekaldelsen forklares den grundlæggende adfærd i det fremtidige bibliotek også. Grundlæggende viden om C ++ og dens markører er nødvendig for forståelsen af denne artikel.

Artikelindhold

Grundlæggende ordning for tilbagekaldsfunktion
Synkron adfærd med tilbagekaldsfunktion
Asynkron adfærd med tilbagekaldsfunktion
Grundlæggende brug af det fremtidige bibliotek
Konklusion

Grundlæggende ordning for tilbagekaldsfunktion

En ordning med tilbagekaldsfunktioner har brug for en hovedfunktion, og selve tilbagekaldsfunktionen. Erklæringen om tilbagekaldelsesfunktionen er en del af parameterlisten for hovedfunktionen. Definitionen af tilbagekaldsfunktionen er angivet i hovedopgavens funktionsopkald. Tilbagekaldsfunktionen kaldes faktisk inden for definitionen af hovedfunktionen. Følgende program illustrerer dette:

#omfatte
ved hjælp af namespace std;
int principFn (char ch [], int (* ptr) (int))

int id1 = 1;
int id2 = 2;
int idr = (* ptr) (id2);
cout<<"principal function: "<returnere id1;

int cb (int iden)

cout<<"callback function"<<'\n';
returnere iden;

int main ()

int (* ptr) (int) = &cb;
char cha [] = "og";
principFn (cha, cb);
returnere 0;

Outputtet er:

tilbagekaldsfunktion
hovedfunktion: 1 og 2

Hovedfunktionen identificeres af principalFn (). Tilbagekaldsfunktionen er identificeret ved cb (). Tilbagekaldsfunktionen er defineret uden for hovedfunktionen, men kaldes faktisk inden for hovedfunktionen.

Bemærk erklæringen om tilbagekaldsfunktionen som en parameter i parameterlisten i hovedfunktionserklæringen. Erklæringen om tilbagekaldsfunktionen er “int (* ptr) (int)”. Bemærk tilbagekaldsfunktionsudtrykket, som et funktionsopkald, i definitionen af hovedfunktionen; ethvert argument for callback-funktionskaldet sendes der. Erklæringen for dette funktionsopkald er:

int idr = (* ptr) (id2);

Hvor id2 er et argument. ptr er en del af parameteren, en markør, der linkes til referencen for tilbagekaldsfunktionen i hovedfunktionen ().

Bemærk udtrykket:

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

I hovedfunktionen (), der forbinder erklæringen (uden definition) af tilbagekaldsfunktionen til navnet på definitionen af den samme tilbagekaldsfunktion.

Hovedfunktionen kaldes i hovedfunktionen () som:

principFn (cha, cb);

Hvor cha er en streng og cb er navnet på tilbagekaldsfunktionen uden noget af dens argument.

Synkron opførsel af tilbagekaldsfunktion

Overvej følgende program:

#omfatte
ved hjælp af namespace std;
ugyldig principFn (ugyldig (* ptr) ())

cout<<"principal function"<<'\n';
(* ptr) ();

ugyldig cb ()

cout<<"callback function"<<'\n';

ugyldigt fn ()

cout<<"seen"<<'\n';

int main ()

ugyldigt (* ptr) () = &cb;
principFn (cb);
fn ();
returnere 0;

Outputtet er:

hovedfunktion
tilbagekaldsfunktion
set

Der er en ny funktion her. Alt, hvad den nye funktion gør, er at vise output, "set". I hovedfunktionen () kaldes hovedfunktionen, derefter kaldes den nye funktion, fn (). Outputtet viser, at koden for hovedfunktionen blev udført, derefter blev den for tilbagekaldsfunktionen udført, og til sidst blev den for fn () -funktionen udført. Dette er synkron opførsel (en tråd).

Hvis det var asynkron opførsel, når tre kodesegmenter kaldes i rækkefølge, kan det første kodesegment udføres, efterfulgt i stedet af udførelsen af det tredje kodesegment, før det andet kodesegment udføres.

Funktionen fn () kan kaldes fra definitionen af hovedfunktionen i stedet for fra hovedfunktionen () som følger:

#omfatte
ved hjælp af namespace std;
ugyldigt fn ()

cout<<"seen"<<'\n';

ugyldig principFn (ugyldig (* ptr) ())

cout<<"principal function"<<'\n';
fn ();
(* ptr) ();

ugyldig cb ()

cout<<"callback function"<<'\n';

int main ()

ugyldigt (* ptr) () = &cb;
principFn (cb);
returnere 0;

Outputtet er:

hovedfunktion
set
tilbagekaldsfunktion

Dette er en efterligning af asynkron opførsel. Det er ikke asynkron opførsel. Det er stadig synkron opførsel.

Også rækkefølgen af udførelse af kodesegmentet for hovedfunktionen og kodesegmentet for tilbagekaldsfunktionen kan byttes i definitionen af hovedfunktionen. Følgende program illustrerer dette:

#omfatte
ved hjælp af namespace std;

ugyldig principFn (ugyldig (* ptr) ())

(* ptr) ();
cout<<"principal function"<<'\n';

ugyldig cb ()

cout<<"callback function"<<'\n';

ugyldigt fn ()

cout<<"seen"<<'\n';

int main ()

ugyldigt (* ptr) () = &cb;
principFn (cb);
fn ();
returnere 0;

Outputtet er nu,

tilbagekaldsfunktion
hovedfunktion
set

Dette er også en efterligning af asynkron opførsel. Det er ikke asynkron opførsel. Det er stadig synkron opførsel. Ægte asynkron opførsel kan opnås som forklaret i næste afsnit eller med biblioteket, fremtid.

Asynkron adfærd med tilbagekaldsfunktion

Pseudokoden til den grundlæggende asynkrone tilbagekaldsfunktionsplan er:

type output;
type cb (type output)

// udsagn

type principalFn (type input, type cb (type output))

// udsagn

Bemærk placeringen af input- og outputdata de forskellige steder i pseudokoden. Indgangen til tilbagekaldsfunktionen er dens output. Parameterne for hovedfunktionen er inputparameteren for den generelle kode og parameteren for tilbagekaldsfunktionen. Med denne ordning kan en tredje funktion udføres (kaldes) i hovedfunktionen () før output fra tilbagekaldsfunktionen læses (stadig i hovedfunktionen ()). Følgende kode illustrerer dette:

#omfatte
ved hjælp af namespace std;
char * output;
ugyldig cb (char out [])

output = ud;

void principalFn (char input [], void (* ptr) (char [50]))

(* ptr) (input);
cout<<"principal function"<<'\n';

ugyldigt fn ()

cout<<"seen"<<'\n';

int main ()

char input [] = "tilbagekaldsfunktion";
ugyldigt (* ptr) (char []) = &cb;
principFn (input, cb);
fn ();
cout<returnere 0;

Programmets output er:

hovedfunktion
set
tilbagekaldsfunktion

I denne bestemte kode er output- og inputdato tilfældigvis det samme datum. Resultatet af det tredje funktionsopkald i hovedfunktionen () er vist før resultatet af tilbagekaldsfunktionen. Tilbagekaldsfunktionen blev udført, afsluttet og tildelt sit resultat (værdi) til variablen, output, så programmet kunne fortsætte uden dets interferens. I hovedfunktionen () blev output fra tilbagekaldsfunktionen brugt (læst og vist), når det var nødvendigt, hvilket førte til asynkron opførsel for hele skemaet.

Dette er den enkelt trådede måde at opnå tilbagekaldsfunktion asynkron opførsel med ren C++.

Grundlæggende brug af det fremtidige bibliotek

Ideen med den asynkrone tilbagekaldsfunktionsplan er, at hovedfunktionen vender tilbage, før tilbagekaldsfunktionen vender tilbage. Dette blev gjort indirekte, effektivt i ovenstående kode.

Bemærk fra ovenstående kode, at tilbagekaldsfunktionen modtager hovedindgangen for koden og producerer hovedudgangen for koden. C ++ - biblioteket, fremtiden, har en funktion kaldet sync (). Det første argument til denne funktion er referencen til tilbagekaldsfunktion; det andet argument er input til tilbagekaldsfunktionen. Funktionen sync () vender tilbage uden at vente på, at udførelsen af tilbagekaldsfunktionen er afsluttet, men tillader tilbagekaldsfunktionen at fuldføre. Dette giver asynkron opførsel. Mens tilbagekaldsfunktionen fortsætter med at udføre, da synkroniseringsfunktionen () allerede er returneret, fortsætter udsagnene nedenfor. Dette er som ideel asynkron opførsel.

Ovenstående program er blevet omskrevet nedenfor under hensyntagen til det fremtidige bibliotek og dets sync () -funktion:

#omfatte
#omfatte
#omfatte
ved hjælp af namespace std;
fremtid produktion;
streng cb (streng stri)

returnere stri;

ugyldig principalFn (strenginput)

output = asynkronisering (cb, input);
cout<<"principal function"<<'\n';

ugyldigt fn ()

cout<<"seen"<<'\n';

int main ()

string input = string ("callback-funktion");
principFn (input);
fn ();
streng ret = output.få(); // venter på tilbagekald, hvis det er nødvendigt
cout<returnere 0;

Funktionen sync () lagrer endelig output fra tilbagekaldsfunktionen i det fremtidige objekt. Den forventede output kan opnås i hovedfunktionen () ved hjælp af get () medlemsfunktionen for det fremtidige objekt.

Konklusion

En tilbagekaldsfunktion er en funktion, der er et argument, ikke en parameter, i en anden funktion. En ordning med tilbagekaldsfunktioner har brug for en hovedfunktion og selve tilbagekaldsfunktionen. Erklæringen om tilbagekaldelsesfunktionen er en del af parameterlisten for hovedfunktionen. Definitionen af tilbagekaldsfunktionen er angivet i funktionsopkaldet til hovedfunktionen (i hoved ()). Tilbagekaldsfunktionen kaldes faktisk inden for definitionen af hovedfunktionen.

Et skema til tilbagekaldsfunktion er ikke nødvendigvis asynkront. For at være sikker på, at tilbagekaldsfunktionsskemaet er asynkront, skal du indtaste hovedindgangen til koden, input til tilbagekaldsfunktionen; lav hovedudgangen af koden, udgangen af tilbagekaldsfunktionen; gemme output fra tilbagekaldsfunktionen i en variabel eller datastruktur. I hovedfunktionen () skal du udføre andre udsagn om applikationen efter at have kaldt til hovedfunktionen. Når der er behov for output fra tilbagekaldsfunktionen, skal du i hovedfunktionen () bruge (læse og vise) den der og derefter.