Tilbakeringingsfunksjon i C ++

En tilbakeringingsfunksjon er en funksjon, som er et argument, ikke en parameter, i en annen funksjon. Den andre funksjonen kan kalles hovedfunksjonen. Så to funksjoner er involvert: hovedfunksjonen og tilbakeringingsfunksjonen i seg selv. I parameterlisten over hovedfunksjonen er erklæringen om tilbakeringingsfunksjonen uten dens definisjon til stede, akkurat som objektdeklarasjoner uten tildeling er til stede. Hovedfunksjonen kalles med argumenter (i Main ()). Et av argumentene i hovedfunksjonssamtalen er den effektive definisjonen av tilbakeringingsfunksjonen. I C ++ er dette argumentet en referanse til definisjonen av tilbakeringingsfunksjonen; det er ikke den faktiske definisjonen. Tilbakeringingsfunksjonen i seg selv kalles faktisk innenfor definisjonen av hovedfunksjonen.

Den grunnleggende tilbakeringingsfunksjonen i C ++ garanterer ikke asynkron oppførsel i et program. Asynkron oppførsel er den virkelige fordelen med tilbakeringingsfunksjonsordningen. I den asynkrone tilbakeringingsfunksjonsordningen bør resultatet av hovedfunksjonen oppnås for programmet før resultatet av tilbakeringingsfunksjonen oppnås. Det er mulig å gjøre dette i C ++; Imidlertid har C ++ et bibliotek som heter Future for å garantere oppførselen til den asynkrone tilbakeringingsfunksjonsordningen.

Denne artikkelen forklarer den grunnleggende tilbakeringingsfunksjonsskjemaet. Mye av det er med ren C++. Når det gjelder tilbakeringingen, blir også den grunnleggende oppførselen til det fremtidige biblioteket forklart. Grunnleggende kunnskap om C ++ og dens pekere er nødvendig for forståelsen av denne artikkelen.

Artikkelinnhold

• Grunnleggende tilbakeringingsfunksjonsskjema
• Synkron oppførsel med tilbakeringingsfunksjon
• Asynkron oppførsel med tilbakeringingsfunksjon
• Grunnleggende bruk av det fremtidige biblioteket
• Konklusjon

Grunnleggende tilbakeringingsfunksjonsskjema

Et tilbakeringingsfunksjonsordning trenger en hovedfunksjon, og tilbakeringingsfunksjonen i seg selv. Erklæringen om tilbakeringingsfunksjonen er en del av parameterlisten over hovedfunksjonen. Definisjonen av tilbakeringingsfunksjonen er indikert i funksjonssamtalen til hovedfunksjonen. Tilbakeringingsfunksjonen kalles faktisk innenfor definisjonen av hovedfunksjonen. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
int principfn (char ch [], int (*ptr) (int))

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

Int CB (int iDen)

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

int main ()

int (*ptr) (int) = &cb;
char cha [] = "og";
PrincipalFn (Cha, CB);
retur 0;

Utgangen er:

tilbakeringingsfunksjon
Hovedfunksjon: 1 og 2

Hovedfunksjonen identifiseres av PrincipalFN (). Tilbakeringingsfunksjonen er identifisert av CB (). Tilbakeringingsfunksjonen er definert utenfor hovedfunksjonen, men faktisk kalt innenfor hovedfunksjonen.

Legg merke til erklæringen om tilbakeringingsfunksjonen som en parameter i parameterlisten over hovedfunksjonserklæringen. Erklæringen om tilbakeringingsfunksjonen er “int (*ptr) (int)”. Legg merke til tilbakeringingsfunksjonsuttrykket, som en funksjonsanrop, i definisjonen av hovedfunksjonen; Ethvert argument for tilbakeringingsfunksjonsanropet blir gitt dit. Uttalelsen for denne funksjonssamtalen er:

int idr = (*ptr) (id2);

Der ID2 er et argument. PTR er en del av parameteren, en peker, som vil være koblet til referansen til tilbakeringingsfunksjonen i Main () -funksjonen.

Legg merke til uttrykket:

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

I hovedfunksjonen () som knytter erklæringen (uten definisjon) av tilbakeringingsfunksjonen til navnet på definisjonen av samme tilbakeringingsfunksjon.

Hovedfunksjonen kalles, i Main () -funksjonen, som:

PrincipalFn (Cha, CB);

Hvor CHA er en streng og CB er navnet på tilbakeringingsfunksjonen uten noe av argumentet.

Synkron oppførsel av tilbakeringingsfunksjon

Tenk på følgende program:

#inkludere
ved hjelp av navneområdet STD;
void PrincipalFn (void (*ptr) ())

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

void CB ()

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

ugyldig fn ()

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

int main ()

void (*ptr) () = &cb;
PrincipalFN (CB);
fn ();
retur 0;

Utgangen er:

Hovedfunksjon
tilbakeringingsfunksjon
sett

Det er en ny funksjon her. All den nye funksjonen gjør, er å vise utdataene, "sett". I hovedfunksjonen () kalles hovedfunksjonen, så kalles den nye funksjonen, FN (). Utgangen viser at koden for hovedfunksjonen ble utført, da ble for tilbakeringingsfunksjonen utført, og til slutt den for FN () -funksjonen ble utført. Dette er synkron (enkelttrådet) oppførsel.

Hvis det var asynkron oppførsel, når tre kodesegmenter kalles i rekkefølge, kan det første kodesegmentet utføres, fulgt i stedet av utførelsen av det tredje kodesegmentet, før det andre kodesegmentet blir utført.

Vel, funksjonen, fn () kan kalles innen definisjonen av hovedfunksjonen, i stedet for fra innen hoved () -funksjonen, som følger:

#inkludere
ved hjelp av navneområdet STD;
ugyldig fn ()

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

void PrincipalFn (void (*ptr) ())

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

void CB ()

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

int main ()

void (*ptr) () = &cb;
PrincipalFN (CB);
retur 0;

Utgangen er:

Hovedfunksjon
sett
tilbakeringingsfunksjon

Dette er en etterligning av asynkron oppførsel. Det er ikke asynkron oppførsel. Det er fremdeles synkron oppførsel.

Også utførelsesrekkefølgen av kodesegmentet til hovedfunksjonen og kodesegmentet til tilbakeringingsfunksjonen kan byttes i definisjonen av hovedfunksjonen. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
void PrincipalFn (void (*ptr) ())

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

void CB ()

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

ugyldig fn ()

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

int main ()

void (*ptr) () = &cb;
PrincipalFN (CB);
fn ();
retur 0;

Utgangen er nå,

tilbakeringingsfunksjon
Hovedfunksjon
sett

Dette er også en etterligning av asynkron oppførsel. Det er ikke asynkron oppførsel. Det er fremdeles synkron oppførsel. Ekte asynkron oppførsel kan oppnås som forklart i neste avsnitt eller med biblioteket, fremtid.

Asynkron oppførsel med tilbakeringingsfunksjon

Pseudokoden for den grunnleggende asynkrone tilbakeringingsfunksjonsskjemaet er:

type utgang;
Type CB (Type Output)

// uttalelser

Type PrincipalFN (Type Input, Type CB (Type Output))

// uttalelser

Legg merke til posisjonene til inngangs- og utgangsdataene på de forskjellige stedene i pseudokoden. Inngangen til tilbakeringingsfunksjonen er utdata. Parametrene til hovedfunksjonen er inngangsparameteren for den generelle koden og parameteren for tilbakeringingsfunksjonen. Med dette skjemaet kan en tredje funksjon utføres (kalt) i hovedfunksjonen () før utgangen fra tilbakeringingsfunksjonen blir lest (fremdeles i Main () -funksjonen). Følgende kode illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
char *output;
void CB (Char Out [])

utgang = ut;

void PrincipalFn (Char Input [], Void (*PTR) (Char [50]))

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

ugyldig fn ()

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

int main ()

char input [] = "tilbakeringingsfunksjon";
void (*ptr) (char []) = &cb;
PrincipalFN (input, CB);
fn ();
cout<retur 0;

Programutgangen er:

Hovedfunksjon
sett
tilbakeringingsfunksjon

I denne spesielle koden skjer output og inngangsdatum det samme punktet. Resultatet av den tredje funksjonssamtalen i Main () -funksjonen har blitt vist før resultatet av tilbakeringingsfunksjonen. Tilbaketrekksfunksjonen som ble utført, ferdig og tildelt resultatet (verdien) til variabelen, output, slik at programmet kan fortsette uten interferens. I hovedfunksjonen () ble utgangen fra tilbakeringingsfunksjonen brukt (lest og vist) når den var nødvendig, noe som førte til asynkron oppførsel for hele skjemaet.

Dette er den entrådede måten å oppnå tilbakeringingsfunksjon asynkron oppførsel med ren C++.

Grunnleggende bruk av det fremtidige biblioteket

Ideen om den asynkrone tilbakeringingsfunksjonen er at hovedfunksjonen kommer tilbake før tilbakeringingsfunksjonen kommer tilbake. Dette ble gjort indirekte, effektivt, i koden ovenfor.

Merk fra ovennevnte kode at tilbakeringingsfunksjonen mottar hovedinngangen for koden og produserer hovedutgangen for koden. C ++ -biblioteket, Future, har en funksjon som heter Sync (). Det første argumentet for denne funksjonen er tilbakeringingsfunksjonsreferansen; Det andre argumentet er innspillet til tilbakeringingsfunksjonen. Synkroniseringsfunksjonen returnerer uten å vente på at utførelsen av tilbakeringingsfunksjonen skal fullføres, men lar tilbakeringingsfunksjonen fullføre. Dette gir asynkron oppførsel. Mens tilbakeringingsfunksjonen fortsetter å utføre, siden Sync () -funksjonen allerede har kommet tilbake, fortsetter uttalelsene under den å utføre. Dette er som ideell asynkron oppførsel.

Ovennevnte program er skrevet om nedenfor, tatt i betraktning, det fremtidige biblioteket og dets synkroniseringsfunksjon:

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
framtid produksjon;
Streng CB (String Stri)

returner Stri;

void PrincipalFn (strenginngang)

utgang = async (CB, input);
cout<<"principal function"<<'\n';

ugyldig fn ()

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

int main ()

String input = String ("tilbakeringingsfunksjon");
PrincipalFn (input);
fn ();
String Ret = Output.få(); // venter på at tilbakeringing kommer tilbake om nødvendig
cout<retur 0;

Synkroniseringsfunksjonen lagrer endelig utgangen fra tilbakeringingsfunksjonen i det fremtidige objektet. Den forventede utgang.

Konklusjon

En tilbakeringingsfunksjon er en funksjon, som er et argument, ikke en parameter, i en annen funksjon. Et tilbakeringingsfunksjonsordning trenger en hovedfunksjon, og tilbakeringingsfunksjonen i seg selv. Erklæringen om tilbakeringingsfunksjonen er en del av parameterlisten over hovedfunksjonen. Definisjonen av tilbakeringingsfunksjonen er indikert i funksjonssamtalen til hovedfunksjonen (i Main ()). Tilbakeringingsfunksjonen kalles faktisk innenfor definisjonen av hovedfunksjonen.

Et tilbakeringingsfunksjonsordning er ikke nødvendigvis asynkron. For å være sikker på at tilbakeringingsfunksjonsskjemaet er asynkron, gjør hovedinngangen til koden, inngangen til tilbakeringingsfunksjonen; Gjør hovedutgangen til koden, utgangen fra tilbakeringingsfunksjonen; Lagre utgangen fra tilbakeringingsfunksjonen i en variabel eller datastruktur. I main () -funksjonen, etter å ha ringt hovedfunksjonen, utfører andre utsagn fra applikasjonen. Når utgangen fra tilbakeringingsfunksjonen er nødvendig, i Main () -funksjonen, bruk (les og vis) den der og da.