Phenquestions
A visszahívási függvény egy olyan függvény, amely egy másik függvény argumentuma, nem pedig paramétere. A másik függvény főfunkciónak nevezhető. Tehát két funkció vesz részt: a fő funkció és maga a visszahívási funkció. A fő függvény paraméterlistájában a visszahívási függvény deklarációja a definíciója nélkül jelen van, csakúgy, mint hozzárendelés nélküli objektum deklarációk. A fő funkciót argumentumokkal hívjuk meg (a main ()). A fő függvényhívás egyik argumentuma a visszahívási függvény hatékony meghatározása. A C ++ nyelven ez az argumentum a visszahívási függvény definíciójára utal; ez nem a tényleges meghatározás. Magát a visszahívási függvényt a fő függvény meghatározásán belül hívják meg.
A C ++ rendszer alapvető visszahívási funkciója nem garantálja az aszinkron viselkedést egy programban. Az aszinkron viselkedés a visszahívási függvény séma valódi előnye. Az aszinkron visszahívási függvény sémában a fő funkció eredményét meg kell szerezni a program számára, mielőtt a visszahívási funkció eredményét megkapnák. Ez lehetséges C ++ nyelven; a C ++ könyvtárnak azonban van egy jövője nevű könyvtár, amely garantálja az aszinkron visszahívási függvény séma viselkedését.
Ez a cikk elmagyarázza az alapvető visszahívási funkció sémáját. Nagyon sok tiszta C-vel van++. Ami a visszahívást illeti, a leendő könyvtár alapvető viselkedését is elmagyarázzák. A cikk megértéséhez alapvető ismeretek szükségesek a C ++ -ról és annak mutatóiról.
A cikk tartalma
- Alapvető visszahívási funkció séma
- Szinkron viselkedés visszahívási funkcióval
- Aszinkron viselkedés visszahívási funkcióval
- A leendő könyvtár alapvető felhasználása
- Következtetés
Alapvető visszahívási funkció séma
A visszahívási függvény sémának szüksége van egy fő funkcióra, és magára a visszahívási funkcióra. A visszahívási függvény deklarációja a fő funkció paraméterlistájának része. A visszahívási függvény definícióját a fő funkció függvényhívása jelzi. A visszahívási függvényt valójában a fő függvény meghatározásán belül hívják meg. A következő program ezt szemlélteti:
#includenévtér használata std;
int főFn (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';
return iden;
int main ()
int (* ptr) (int) = &cb;
char cha [] = "és";
főFn (cha, cb);
visszatér 0;
A kimenet:
visszahívási funkciófő funkciója: 1 és 2
A fő funkciót a basicFn () azonosítja. A visszahívási funkciót a cb () azonosítja. A visszahívási funkciót a fő függvényen kívül definiálják, de a fő függvényen belül ténylegesen meghívják.
Jegyezze fel a visszahívási függvény deklarációját paraméterként a fő funkció deklaráció paraméterlistájába. A visszahívási függvény deklarációja: „int (* ptr) (int)”. Vegye figyelembe a visszahívási függvény kifejezést, mint egy függvényhívást, a fő függvény meghatározásában; a visszahívási függvény hívásának bármely argumentuma átadódik. A függvényhívás állítása:
int idr = (* ptr) (id2);Ahol az id2 argumentum. A ptr a paraméter része, egy mutató, amely összekapcsolódik a visszahívási függvény referenciájával a main () függvényben.
Vegye figyelembe a következő kifejezést:
int (* ptr) (int) = &cb;A main () függvényben, amely a visszahívási függvény deklarációját (definíció nélkül) összeköti ugyanazon visszahívási függvény definíciójának nevével.
Az elsődleges függvényt a main () függvényben a következőképpen hívjuk:
főFn (cha, cb);Ahol a cha egy karakterlánc, a cb pedig a visszahívási függvény neve annak argumentuma nélkül.
A visszahívási funkció szinkron viselkedése
Fontolja meg a következő programot:
#includenévtér használata std;
void basicFn (void (* ptr) ())
cout<<"principal function"<<'\n';
(* ptr) ();
void cb ()
cout<<"callback function"<<'\n';
void fn ()
cout<<"seen"<<'\n';
int main ()
void (* ptr) () = &cb;
főFn (cb);
fn ();
visszatér 0;
A kimenet:
fő funkciójavisszahívási funkció
látott
Itt van egy új funkció. Az összes új funkció az, hogy megjelenítse a kimenetet, „látva”. A main () függvényben a fő függvényt hívják meg, majd meghívják az új, fn () függvényt. A kimenet azt mutatja, hogy az elsődleges függvény kódja végrehajtásra került, majd a visszahívási funkció kódja és végül az fn () függvény végrehajtása. Ez szinkron (egyszálas) viselkedés.
Ha aszinkron viselkedés volt, amikor három kódszegmenst hívnak egymás után, akkor az első kódszegmens futtatható, majd a harmadik kódszegmens végrehajtása következik a második kódszegmens végrehajtása előtt.
Nos, az fn () függvény a fő () függvény meghatározása helyett meghívható a main () függvény helyett, az alábbiak szerint:
#includenévtér használata std;
void fn ()
cout<<"seen"<<'\n';
void basicFn (void (* ptr) ())
cout<<"principal function"<<'\n';
fn ();
(* ptr) ();
void cb ()
cout<<"callback function"<<'\n';
int main ()
void (* ptr) () = &cb;
főFn (cb);
visszatér 0;
A kimenet:
fő funkciójalátott
visszahívási funkció
Ez az aszinkron viselkedés utánzata. Ez nem aszinkron viselkedés. Ez továbbra is szinkron viselkedés.
Emellett a fő funkció kódszegmensének és a visszahívási funkció kódszegmensének végrehajtási sorrendje felcserélhető a fő függvény meghatározásában. A következő program ezt szemlélteti:
#includenévtér használata std;
void basicFn (void (* ptr) ())
(* ptr) ();
cout<<"principal function"<<'\n';
void cb ()
cout<<"callback function"<<'\n';
void fn ()
cout<<"seen"<<'\n';
int main ()
void (* ptr) () = &cb;
főFn (cb);
fn ();
visszatér 0;
A kimenet most,
visszahívási funkciófő funkciója
látott
Ez az aszinkron viselkedés utánzata is. Ez nem aszinkron viselkedés. Ez továbbra is szinkron viselkedés. Az igazi aszinkron viselkedés a következő szakaszban leírtak szerint vagy a jövő könyvtárával magyarázható.
Aszinkron viselkedés visszahívási funkcióval
Az alapvető aszinkron visszahívási függvény sémájának álkódja:
típusú kimenet;cb típus (type output)
// állítások
type basicFn (type input, type cb (type output))
// állítások
Jegyezze fel a bemeneti és kimeneti adatok helyzetét az álkód különböző helyein. A visszahívási funkció bemenete annak kimenete. A fő funkció paraméterei az általános kód bemeneti paraméterei és a visszahívási funkció paraméterei. Ezzel a sémával egy harmadik függvény futtatható (hívható) a main () függvényben, mielőtt a visszahívási funkció kimenete beolvasásra kerülne (még mindig a main () függvényben). A következő kód ezt szemlélteti:
#includenévtér használata std;
char * output;
void cb (char out [])
kimenet = ki;
void basicFn (char bemenet [], void (* ptr) (char [50]))
(* ptr) (bemenet);
cout<<"principal function"<<'\n';
void fn ()
cout<<"seen"<<'\n';
int main ()
char input [] = "visszahívási funkció";
void (* ptr) (char []) = &cb;
főFn (bemenet, cb);
fn ();
cout<
A program kimenete:
fő funkciójalátott
visszahívási funkció
Ebben a bizonyos kódban a kimeneti és a bemeneti nullapont történetesen ugyanaz a nullapont. A fő () függvényben a harmadik függvényhívás eredménye a visszahívási funkció eredménye előtt látható. A visszahívási funkció végrehajtotta, befejezte és az eredményt (értéket) a kimenet változóhoz rendelte, lehetővé téve a program folytatását interferenciája nélkül. A main () függvényben a visszahívási függvény kimenetét használták (olvasta és jelenítette meg), amikor arra szükség volt, ami aszinkron viselkedéshez vezetett az egész sémánál.
Ez az egyszálú módszer a visszahívási függvény aszinkron viselkedésének elérésére tiszta C-vel++.
A leendő könyvtár alapvető felhasználása
Az aszinkron visszahívási függvény séma ötlete az, hogy a fő függvény visszatér, mielőtt a visszahívási funkció visszatér. Ez közvetetten, hatékonyan történt a fenti kódban.
A fenti kódból vegye figyelembe, hogy a visszahívási funkció megkapja a kód fő bemenetét, és előállítja a kód fő kimenetét. A jövőbeli C ++ könyvtárnak van egy sync () nevű funkciója. Ennek a függvénynek az első argumentuma a visszahívási függvény hivatkozása; a második argumentum a visszahívási funkció bemenete. A sync () függvény visszatér, anélkül, hogy megvárná a visszahívási funkció végrehajtását, de lehetővé teszi a visszahívási funkció befejezését. Ez aszinkron viselkedést biztosít. Míg a visszahívási funkció továbbra is végrehajtódik, mivel a sync () függvény már visszaállt, az alatta lévő utasítások továbbra is végrehajtják. Ez olyan, mint az ideális aszinkron viselkedés.
A fenti programot az alábbiakban átírtuk, figyelembe véve a leendő könyvtárat és annak szinkronizálási () funkcióját:
#include#include
#include
névtér használata std;
jövő
string cb (string stri)
visszatérő csík;
void mainFn (karakterlánc bemenet)
output = aszinkron (cb, input);
cout<<"principal function"<<'\n';
void fn ()
cout<<"seen"<<'\n';
int main ()
string input = string ("visszahívási függvény");
főFn (bemenet);
fn ();
string ret = kimenet.kap(); // szükség esetén várja a visszahívás visszatérését
cout<
A sync () függvény végül a visszahívási funkció kimenetét tárolja a jövő objektumába. A várható kimenetet a main () függvényben lehet megkapni, a jövő objektum get () tagjának függvényét felhasználva.
Következtetés
A visszahívási függvény egy olyan függvény, amely egy másik függvény argumentuma, nem pedig paramétere. A visszahívási függvény sémának szüksége van egy fő funkcióra, és magára a visszahívási funkcióra. A visszahívási függvény deklarációja a fő funkció paraméterlistájának része. A visszahívási függvény definícióját a fő függvény függvényhívása jelzi (a main () -ban). A visszahívási függvényt valójában a fő függvény meghatározásán belül hívják meg.
A visszahívási függvény séma nem feltétlenül aszinkron. Annak érdekében, hogy a visszahívási függvény sémája aszinkron legyen, adja meg a kód fő bemenetét, a visszahívás funkció bemenetét; készítse el a kód fő kimenetét, a visszahívási funkció kimenetét; tárolja a visszahívási függvény kimenetét egy változóban vagy adatstruktúrában. A main () függvényben, a main függvény meghívása után hajtsa végre az alkalmazás egyéb utasításait. Ha a visszahívási funkció kimenetére van szükség, akkor a main () függvényben használja (olvassa és jelenítse meg) azt ott és akkor.
