Phenquestions
Szintaxis hibák
A helytelenül beírt kifejezés, utasítás vagy konstrukció szintaktikai hiba.
Vegye figyelembe a következő két állítást:
int arr [] = 1, 2, 3; //helyesint arr = 1, 2, 3; // szintaktikai hiba, hiányzik []
Ugyanannak a tömbnek a definíciói. Az első helyes. A második hiányzik [], és ez egy szintaktikai hiba. A szintaktikai hibával rendelkező programot nem sikerül lefordítani. A fordítás sikertelen a szintaktikai hibát jelző hibaüzenettel. Még jó, hogy a szintaxis hibát mindig ki lehet javítani, ha a programozó tudja, mit csinál.
Logikai hiba
A logikai hiba a programozó által elkövetett hiba, ha valamilyen hibás logikai kódolást hajtanak végre. Ennek oka lehet a programozó tudatlansága a programozási nyelv jellemzői felé vagy annak félreértése, hogy a program mit kell tennie.
Ebben a helyzetben a program összeállítása sikeres. A program jól működik, de rossz eredményeket produkál. Egy ilyen hiba oka lehet, hogy a ciklus ötször ismétlődik, amikor 10-szer ismétlődik. Az is előfordulhat, hogy öntudatlanul hurok készül a végtelen iterációra. Az ilyen hibák megoldásának egyetlen módja az, hogy gondosan programozzon és alaposan tesztelje a programot, mielőtt átadná az ügyfélnek.
Futásidejű hibák
A helytelen vagy kivételes bemenetek futásidejű hibákat okoznak. Ebben az esetben a programot sikeresen fordították és sok helyzetben jól működik. Bizonyos helyzetekben a program összeomlik (és leáll).
Képzeljük el, hogy egy programkódszegmensben a 8-at el kell osztani számos nevezővel. Tehát, ha a 8 számlálót elosztjuk a 4 nevezővel, a válasz (hányados) 2 lesz. Ha azonban a felhasználó 0-t ad meg nevezőnek, akkor a program összeomlik. A 0-val való osztás nem megengedett a matematikában, és a számítástechnikában sem. A programozás során meg kell akadályozni a nullára osztást. A kivételkezelés kezeli a futásidejű hibákat, például a nullára osztást. A következő program bemutatja, hogy miként lehet kezelni a nullával osztás problémáját a C ++ kivétel funkciójának használata nélkül:
#includenévtér használata std;
int main ()
int számláló = 8;
int nevező = 2;
ha (nevező != 0)
int eredmény = számláló / nevező;
cout << result << '\n';
más
cout << "Division by zero is not permitted!" << '\n';
visszatér 0;
A kimenet 4. Ha a nevező 0 volt, a kimenet a következő lett volna:
„A nullával való felosztás nem megengedett!”
A fő kód itt egy if-else konstrukció. Ha a nevező nem 0, akkor a felosztás megtörténik; ha 0, akkor a felosztás nem történik meg. Hibaüzenetet küldünk a felhasználónak, és a program összeomlás nélkül tovább fut. A futásidejű hibákat általában úgy kezelik, hogy elkerülik a kódszegmens végrehajtását, és hibaüzenetet küldenek a felhasználónak.
A C ++ kivétel szolgáltatása az if-blokkhoz egy try-block-ot, az else-blockhoz pedig egy catch-block-ot használ a hiba kezeléséhez, ugyanúgy:
#includenévtér használata std;
int main ()
int számláló = 8;
int nevező = 2;
próbáld ki
ha (nevező != 0)
int eredmény = számláló / nevező;
cout << result << '\n';
más
dobás 0;
fogás (tévedés)
ha (tévedés == 0)
cout << "Division by zero is not permitted!" << '\n';
visszatér 0;
Vegye figyelembe, hogy a try fejlécnek nincs argumentuma. Vegye figyelembe azt is, hogy a catch-block, amely olyan, mint egy függvénydefiníció, rendelkezik egy paraméterrel. A paraméter típusának meg kell egyeznie a dob-kifejezés operandusával (argumentumával). A dobás-kifejezés a try-blokkban található. A programozó által választott, a hibával kapcsolatos érvet dob, és a catch-block elkapja. Ily módon a try-blokk kódja nem kerül végrehajtásra. Ezután a fogási blokk megjeleníti a hibaüzenetet.
Ez a cikk a C-ben szereplő kivételkezelést ismerteti++. Az alapvető ismeretek a C ++ nyelven előfeltétele annak, hogy az olvasó megértse ezt a cikket.
A cikk tartalma:
- Funkció Kivétel dobása
- Egynél több elkapási blokk egy próbálkozás blokkolásához
- Beágyazott próbálkozás / elkapás Blocks
- noexcept-specifier
- A Special std :: terminate () függvény
- Következtetés
Kivétel dobása:
Egy függvény kivételt is hozhat, akárcsak a try-block. A dobás a függvény meghatározásán belül történik. A következő program ezt szemlélteti:
#includenévtér használata std;
void fn (const char * str)
if (alacsonyabb (str [0]))
dobja „l”;
int main ()
próbáld ki
fn ("kovács");
fogás (char ch)
ha (ch == 'l')
cout << "Person's name cannot begin in lowercase!" << '\n';
visszatér 0;
Figyelje meg, hogy ezúttal a try blokk csak a függvényhívást tartalmazza. Az úgynevezett függvény rendelkezik dobással. A fogási blokk elkapja a kivételt, és a kimenet:
- A személy neve nem kezdődhet kisbetűvel!”
Ezúttal a dobott és elkapott típus egy char.
Egynél több elkapási blokk egy próbablokkhoz:
Egy-egy try-blokkhoz egynél több catch-block lehet. Képzelje el azt a helyzetet, amikor egy bevitel lehet a billentyűzet bármelyik karaktere, de nem számjegy és nem ábécé. Ebben az esetben két fogási blokknak kell lennie: egy egész számra a számjegy ellenőrzésére, egy pedig egy betűre az ábécé ellenőrzésére. A következő kód ezt szemlélteti:
#includenévtér használata std;
char input = '*';
int main ()
próbáld ki
if (isdigit (input))
dobás 10;
if (isalpha (bemenet))
dobja a „z” -t;
fogás (int)
cout << "Digit input is forbidden!" << '\n';
fogás (char)
cout << "Character input is forbidden!" << '\n';
visszatér 0;
Nincs kimenet. Ha a bemenet értéke egy számjegy lenne, pl.g., „1”, a kimenet a következő lett volna:
Msgstr "A számjegy bevitele tilos!"
Ha a bemenet értéke ábécé lenne, pl.g., „a”, a kimenet a következő lett volna:
Msgstr "A karakter bevitele tilos!"
Vegye figyelembe, hogy a két fogási blokk paraméterlistájában nincs azonosító neve. Vegye figyelembe azt is, hogy a két fogási blokk meghatározásában az adott érveket nem ellenőrizték, hogy értékeik pontosak-e vagy sem.
A fogás szempontjából fontos a típus; egy fogásnak meg kell egyeznie a dobott operandus típusával. A leadott argumentum (operandus) adott értéke felhasználható a további igazolásra, ha szükséges.
Több kezelő ugyanazon típushoz
Lehetséges két azonos típusú kezelő. Kivétel dobásakor a vezérlés átkerül a legközelebbi kezelőhöz, egyező típussal. A következő program ezt szemlélteti:
#includenévtér használata std;
char input = '1';
int main ()
próbáld ki
if (isdigit (input))
dobás 10;
fogás (int)
cout << "Digit input is forbidden!" << '\n';
fogás (int)
cout << "Not allowed at all: digit input!" << '\n';
visszatér 0;
A kimenet:
Msgstr "A számjegy bevitele tilos!"Beágyazott próba / fogás blokkok:
a try / catch blokkok beágyazhatók. A fenti, nem alfanumerikus karakterek billentyűzetről történő bevitelére szolgáló program itt megismétlődik, de be van ágyazva az ábécés hibakód:
#includenévtér használata std;
char input = '*';
int main ()
próbáld ki
if (isdigit (input))
dobás 10;
próbáld ki
if (isalpha (bemenet))
dobja a „z” -t;
fogás (char)
cout << "Character input is forbidden!" << '\n';
fogás (int)
cout << "Digit input is forbidden!" << '\n';
visszatér 0;
A hibás ábécés try / catch-block a számkód try-blockjában van beágyazva. Ennek a programnak a működése és az előző művelet, amelyről másolták, ugyanaz.
noexcept-specifier
Vegye figyelembe a következő funkciót:
void fn (const char * str) noexceptif (alacsonyabb (str [0]))
dobja „l”;
Figyelje meg a 'noexcept' specifikát közvetlenül a függvényparaméterek listájának jobb zárójelei után. Ez azt jelenti, hogy a függvény nem vethet ki kivételt. Ha a függvény kivételt vet, mint ebben az esetben, akkor figyelmeztető üzenettel áll össze, de nem fog futni. A program futtatására az std :: terminate () speciális függvény hívja meg, amelynek kecsesen le kell állítania a programot ahelyett, hogy csak szó szerint összeomlana.
A noexcept specifikátor különböző formában van. Ezek a következők:
type func () noexcept; : nem engedélyezi a dobás kifejezésttype func () noexcept (true); : lehetővé teszi a dobás kifejezést
type func () dobás (); : nem engedélyezi a dobás kifejezést
type func () noexcept (false); : lehetővé teszi a dobás kifejezést, amely opcionális
type func (); : lehetővé teszi a dobás kifejezést, amely opcionális
a zárójelben szereplő igaz vagy hamis kifejezés helyettesíthető egy kifejezéssel, amely igaz vagy hamis eredményt eredményez.
A Special std :: terminate () függvény:
Ha egy kivétel nem kezelhető, akkor azt újra meg kell dobni. Ebben az esetben a dobott kifejezésnek lehet operandusza, vagy nem. Az std :: terminate () speciális függvény futás közben meghívásra kerül, amelynek kecsesen le kell állítania a programot ahelyett, hogy csak szó szerint összeomlana.
Írja be, fordítsa le és futtassa a következő programot:
#includenévtér használata std;
char input = '1';
int main ()
próbáld ki
if (isdigit (input))
dobás 10;
fogás (int)
dobás;
visszatér 0;
Sikeres összeállítás után a program futás nélkül leállt, és a szerző számítógépéről a következő hibaüzenet érkezett:
„Hívás befejezése, miután dobott egy„ int ”példányt
Megszakítva (mag ki van dobva) ”
Következtetés:
A C ++ kivétel funkciója megakadályozza, hogy egy kódszegmens valamilyen bemenet alapján futtasson. A program szükség szerint folytatja a végrehajtást. A kivétel (hibamegelőzés) konstrukció egy try-blockból és egy catch-blockból áll. A try-blokk érdeklődési körű kódszegmenssel rendelkezik, amely megkerülhető, bizonyos bemeneti feltételektől függően. A try-blokk rendelkezik a dobás kifejezéssel, amely operandot dob. Ezt az operandust kivételnek is nevezik. Ha az operandus típusa és a fogási blokk paraméterének típusa megegyezik, akkor a kivétel elkapásra kerül (kezelve). Ha a kivétel nem fogható el, akkor a program leáll, de mégis biztonságban van, mivel a hibás eredmény elérése érdekében végrehajtandó kódszegmens nem lett végrehajtva. A tipikus kivételkezelés a kódszegmens megkerülését és hibaüzenet küldését jelenti a felhasználónak. A kódszegmens normál bemenetre kerül végrehajtásra, de rossz bemenet esetén kerül megkerülésre.
