A visszahívási függvény egy függvény, amely egy argumentum, nem pedig paraméter egy másik függvényben. A másik függvény nevezhető főfüggvénynek. Tehát két funkcióról van szó: a fő funkcióról és magáról a visszahívási funkcióról. 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, ahogy a hozzárendelés nélküli objektum deklarációk is. A fő függvényt argumentumokkal hívják meg (in main ()). A fő függvényhívás egyik érve a visszahívási funkció hatékony meghatározása. A C ++ nyelvben ez az érv hivatkozás a visszahívási függvény definíciójára; nem ez a tényleges meghatározás. Maga a visszahívási függvény valójában a főfunkció meghatározásán belül van meghívva.
A C ++ alapvető visszahívási funkciója nem garantálja a program aszinkron viselkedését. Az aszinkron viselkedés a visszahívási funkciós séma valódi előnye. Az aszinkron visszahívási 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 megkapjuk. Ezt C ++ nyelven is meg lehet tenni; azonban a C ++ rendelkezik egy jövőbeli nevű könyvtárral, 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át. Sok a tiszta C ++ - ból. Ami a visszahívást illeti, a leendő könyvtár alapvető viselkedését is ismertetjük. A cikk megértéséhez alapvető ismeretek szükségesek a C ++ nyelvről és annak mutatóiról.
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ő használata
- Következtetés
Alapvető visszahívási funkció séma
A visszahívási funkciósémának szüksége van egy fő funkcióra, és magára a visszahívási funkcióra. A visszahívási funkció deklarációja a fő funkció paraméterlistájának része. A visszahívási funkció definícióját a fő funkció funkcióhívása tartalmazza. A visszahívási függvényt valójában a fő funkció definíciójában hívják meg. Az alábbi program ezt szemlélteti:
#befoglalni
segítségével névtérórák;
intmainFn(charch[],int (*ptr)(int))
{
intid1= 1;
intid2= 2;
intáltalában= (*ptr)(id2);
költség<<'fő funkció:'<<id1<<''<<ch<<''<<általában<<' n';
Visszatérésid1;
}
intcb(intident)
{
költség<<'visszahívási funkció'<<' n';
Visszatérésident;
}
intfő-()
{
int (*ptr)(int) = &cb;
charnem[] = 'és';
mainFn(apa, cb);
Visszatérés 0;
}
A kimenet:
visszahívási funkció
fő funkciója: 1 és 2
A fő funkciót a principFn () azonosítja. A visszahívási funkciót a cb () azonosítja. A visszahívási funkciót a fő funkción kívül határozzák meg, de valójában a főfunkción belül hívják meg.
Jegyezze meg a visszahívási funkció deklarációját paraméterként a fő funkció deklaráció paraméterlistájában. A visszahívási függvény deklarációja int (*ptr) (int). Jegyezze meg a visszahívási függvény kifejezését, mint egy függvényhívás, a fő funkció meghatározásában; a visszahívási függvény hívásának minden érve ott kerül átadásra. A függvényhívás állítása a következő:
intáltalában= (*ptr)(id2);
Ahol az id2 egy érv. A ptr a paraméter része, egy mutató, amely a main () függvényben a visszahívási függvény hivatkozásához lesz kapcsolva.
Vegye figyelembe a kifejezést:
int (*ptr)(int) = &cb;A fő () függvényben, amely a visszahívási funkció deklarációját (definíció nélkül) ugyanahhoz a visszahívási funkcióhoz tartozó definíció nevével kapcsolja össze.
A fő funkciót a main () függvényben a következőképpen nevezzük:
mainFn(apa, cb);Ahol a cha karakterlánc, a cb pedig a visszahívási függvény neve annak argumentumai nélkül.
A visszahívási funkció szinkron viselkedése
Tekintsük a következő programot:
#befoglalnisegítségével névtérórák;
üresmainFn(üres (*ptr)())
{
költség<<'fő funkció'<<' n';
(*ptr)();
}
ürescb()
{
költség<<'visszahívási funkció'<<' n';
}
üresfn()
{
költség<<'látott'<<' n';
}
intfő-()
{
üres (*ptr)() = &cb;
mainFn(cb);
fn();
Visszatérés 0;
}
A kimenet:
fő funkciójavisszahívási funkció
látott
Itt van egy új funkció. Az új funkció mindössze annyit tesz, hogy megjeleníti a kimenetet. A main () függvényben a fő függvényt hívják meg, majd az új fn () függvényt. A kimenet azt mutatja, hogy a fő funkció kódját hajtották végre, majd a visszahívási funkciót, végül pedig az fn () függvényt. Ez szinkron (egyszálú) viselkedés.
Ha aszinkron viselkedés lenne, akkor három kódszegmens sorrendben történő meghívásakor végrehajtható az első kódszegmens, amelyet a harmadik kódszegmens végrehajtása követhet a második kódszegmens végrehajtása előtt.
Nos, az fn () függvény a fő függvény definíciójából hívható le, nem pedig a fő () függvényből, az alábbiak szerint:
#befoglalnisegítségével névtérórák;
üresfn()
{
költség<<'látott'<<' n';
}
üresmainFn(üres (*ptr)())
{
költség<<'fő funkció'<<' n';
fn();
(*ptr)();
}
ürescb()
{
költség<<'visszahívási funkció'<<' n';
}
intfő-()
{
üres (*ptr)() = &cb;
mainFn(cb);
Visszatérés 0;
}
A kimenet:
fő funkciójalátott
visszahívási funkció
Ez az aszinkron viselkedés utánzata. Ez nem aszinkron viselkedés. Ez még mindig szinkron viselkedés.
Ezenkívül a főfunkció meghatározásában a fő funkció kódszegmensének és a visszahívási funkció kódszegmensének végrehajtási sorrendje felcserélhető. Az alábbi program ezt szemlélteti:
#befoglalnisegítségével névtérórák;
üresmainFn(üres (*ptr)())
{
(*ptr)();
költség<<'fő funkció'<<' n';
}
ürescb()
{
költség<<'visszahívási funkció'<<' n';
}
üresfn()
{
költség<<'látott'<<' n';
}
intfő-()
{
üres (*ptr)() = &cb;
mainFn(cb);
fn();
Visszatérés 0;
}
A kimenet most,
visszahívási funkciófő funkciója
látott
Ez is az aszinkron viselkedés utánzata. Ez nem aszinkron viselkedés. Ez még mindig szinkron viselkedés. A valódi aszinkron viselkedés a következő részben leírtak szerint, vagy a könyvtár segítségével, a jövőben elérhető.
Aszinkron viselkedés visszahívási funkcióval
Az alapvető aszinkron visszahívási funkcióséma álkódja a következő:
típusú kimenet;típus cb(típusú kimenet)
{
// állítások
}
típusú főFn(típusú bemenet, típus cb(típusú kimenet))
{
// állítások
}
Jegyezze meg a bemeneti és kimeneti adatok helyzetét az álkód különböző helyein. A visszahívási funkció bemenete a 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 is végrehajtható (hívható) a fő () függvényben, mielőtt a visszahívási funkció kimenete beolvasásra kerül (még mindig a fő () függvényben). A következő kód ezt szemlélteti:
#befoglalnisegítségével névtérórák;
char *Kimenet;
ürescb(charki[])
{
Kimenet=ki;
}
üresmainFn(charbemenet[],üres (*ptr)(char[ötven]))
{
(*ptr)(bemenet);
költség<<'fő funkció'<<' n';
}
üresfn()
{
költség<<'látott'<<' n';
}
intfő-()
{
charbemenet[] = 'visszahívási funkció';
üres (*ptr)(char[]) = &cb;
mainFn(bemenet, cb);
fn();
költség<<Kimenet<<' n';
Visszatérés 0;
}
A program kimenete:
fő funkciójalátott
visszahívási funkció
Ebben a kódban a kimeneti és a bemeneti nullapont ugyanaz a nullapont. A fő () funkció harmadik funkcióhívásának eredménye a visszahívási funkció eredménye előtt jelenik meg. A visszahívási funkció végrehajtotta, befejezte, és eredményét (értékét) a kimenet változójához rendelte, lehetővé téve, hogy a program interferencia nélkül folytatódjon. A fő () függvényben a visszahívási funkció kimenetét használták (olvassák és jelenítik meg), amikor szükség volt rá, ami aszinkron viselkedést eredményezett az egész séma esetében.
Ez az egyszálú módszer a visszahívási funkció aszinkron viselkedésének elérésére tiszta C ++-val.
A leendő Könyvtár alapvető használata
Az aszinkron visszahívási függvény sémája az, hogy a fő függvény visszatér, mielőtt a visszahívási funkció visszatér. Ez a fenti kódban közvetve, hatékonyan történt.
Jegyezze meg a fenti kódból, hogy a visszahívási funkció megkapja a kód fő bemenetét, és létrehozza a kód fő kimenetét. A jövőbeli C ++ könyvtárnak van egy szinkron () nevű függvénye. Ennek a függvénynek az első érve a visszahívási függvény hivatkozása; a második argumentum a visszahívási funkció bemenete. A sync () függvény anélkül tér vissza, hogy megvárná a visszahívási funkció végrehajtásának befejezését, de lehetővé teszi a visszahívási funkció befejeződését. Ez aszinkron viselkedést biztosít. Amíg a visszahívási funkció továbbra is fut, mivel a sync () függvény már visszatért, az alatta lévő utasítások továbbra is végrehajtódnak. Ez olyan, mint az ideális aszinkron viselkedés.
A fenti programot az alábbiakban írtuk át, figyelembe véve a jövőbeli könyvtárat és annak szinkronizálási () funkcióját:
#befoglalni#befoglalni
#befoglalni
segítségével névtérórák;
jövő<húr>Kimenet;
karakterlánc cb(húr stri)
{
Visszatérésstri;
}
üresmainFn(karakterlánc bemenet)
{
Kimenet=aszinkron(cb, bemenet);
költség<<'fő funkció'<<' n';
}
üresfn()
{
költség<<'látott'<<' n';
}
intfő-()
{
karakterlánc bemenet=húr('visszahívási funkció');
mainFn(bemenet);
fn();
string ret=Kimenet.kap(); // várja a visszahívást, ha szükséges
költség<<jobb<<' n';
Visszatérés 0;
}
A sync () függvény végül tárolja a visszahívási funkció kimenetét a jövőbeli objektumban. A várt kimenet a fő () függvényben szerezhető be, a jövőbeli objektum get () tagfüggvényének használatával.
Következtetés
A visszahívási függvény egy függvény, amely egy argumentum, nem pedig paraméter egy másik függvényben. A visszahívási funkciósémának szüksége van egy fő funkcióra, és magára a visszahívási funkcióra. A visszahívási funkció deklarációja a fő funkció paraméterlistájának része. A visszahívási funkció definícióját a fő funkció funkcióhívása jelzi (a main () -ban). A visszahívási függvényt valójában a fő funkció definíciójában hívják meg.
A visszahívási funkcióséma nem feltétlenül aszinkron. Annak biztosítására, hogy a visszahívási funkcióséma aszinkron, végezze el a kód fő bemenetét, a visszahívási 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 funkció kimenetét egy változóban vagy adatstruktúrában. A main () függvényben a fő függvény meghívása után hajtsa végre az alkalmazás egyéb utasításait. Amikor a visszahívási funkció kimenetére van szükség, a fő () funkcióban használja (olvassa és jelenítse meg) azt ott és akkor.