1. példa:
Itt található az „iostream”, a fejlécfájl, amelyben számos függvény deklarálva van. Ezeket a függvényeket használjuk, amelyek ebben a fejlécfájlban vannak deklarálva a kódunkban, ezért ezt a fejlécfájlt is beletesszük. Ezek után megvan az „std”, amely ide kerül, mivel a „cin” és a „cout” függvények is definiálva vannak benne. Nem kell „std”-t beírnunk mindezen függvények mellett, ha a kódunk elejére hozzáadjuk a „std névteret”. Ezt követően itt meghívódik a „main()” függvény, amelyet a C++ program illesztőprogram kódjaként is szoktak emlegetni.
Ezután itt használjuk a „try” kulcsszót, amelyben a „my_num1” értéket „35” értékkel inicializáljuk. Ez itt az „int” adattípusú változó. Most helyezzük ezt a változót az „if”-be, és helyezzünk el egy feltételt, amely szerint a „my_num1”-nek nagyobbnak vagy egyenlőnek kell lennie „98”-nál. Ha az adott feltétel teljesül, akkor az „if”-en belül halad előre, és végrehajtja az itt írt utasítást. Használjuk a „cout”-ot, és beszúrunk egy üzenetet, amely megjelenik, ha a feltétel teljesül.
Ezek után az „else” behelyezése után a „dob” kulcsszót használjuk. Ebben a „dobás” kulcsszóban a „my_num1” paramétert adjuk meg. Ez alá adjuk a „fogás” részt. A „catch()” paramétereként beszúrjuk a „my_num2”-t, majd a „catch” részben ismét használjuk a „cout”-t. Ez a rész csak akkor fut le, ha kivétel történik a „try” részben.
1. kód:
#include
segítségével névtér std ;
int fő- ( ) {
próbáld ki {
int my_num1 = 35 ;
ha ( my_num1 >= 98 ) {
cout << 'A hozzáférés itt biztosított.' ;
} más {
dobás ( my_num1 ) ;
}
}
fogás ( int my_num2 ) {
cout << – Itt a hozzáférés megtagadva. << endl ;
cout << 'A szám:' << my_num2 ;
}
Visszatérés 0 ;
}
Kimenet:
A beírt szám „35”, ami kisebb, mint „98”. Tehát ott történik a kivétel, és megjelenik a „catch()” rész. A „try” részhez való hozzáférés megtagadva.
2. példa:
Ide helyezzük az „iostream” fejlécfájlt és a „namespace std”-t. Ezt követően létrehozunk egy „division()” függvényt, amelyben két paramétert helyezünk el, amelyek az „int” adattípus „számlálója” és „nevezője”. Ennek a „division” függvénynek az adattípusát „kettős”-re állítjuk.
Ez alá az „if()”-t adjuk, amelyben hozzáadjuk azt a feltételt, hogy a nevező egyenlő nullával. Ezt követően a „dob” kulcsszót használjuk, és oda írunk egy üzenetet. Ez az üzenet akkor jelenik meg, amikor a feltételnek megfelelően kivétel történik ebben a kódban. Ez alatt a „return” kulcsszót használjuk, amelyben a „számláló/nevező” kifejezést helyezzük el. Tehát az osztás eredményét adja vissza. Most a „main()” függvényt hívjuk meg.
Ezt követően a „num1” és a „num2” inicializálódik „int” változóként, és hozzájuk rendeli a „89” és „0” értéket. Ezután inicializáljuk a „dupla” adattípus „eredményét”. Itt a „try” kulcsszót használjuk. Ebben a részben hozzáadjuk ezt az „eredmény” változót, és ehhez a változóhoz rendeljük a „division()” függvényt. Ennek a függvénynek két paramétert adunk át: „szám1” és „szám2”. Ez alatt megjelenítjük azt az „eredményt”, amelyet a „division()” függvény alkalmazása után kapunk. Ezt követően a „catch”-t is használjuk, és elhelyezzük a „const char* msg”-t az előzőleg hozzáadott üzenet megjelenítéséhez.
2. kód:
#includesegítségével névtér std ;
kettős osztály ( int számláló, int névadó ) {
ha ( névadó == 0 ) {
dobás – Itt nem lehet nullával osztani! ;
}
Visszatérés ( számláló / névadó ) ;
}
int fő- ( ) {
int szám1 = 89 ;
int szám2 = 0 ;
kettős eredmény = 0 ;
próbáld ki {
eredmény = osztály ( szám1, szám2 ) ;
cout << eredmény << endl ;
} fogás ( const char * üzenet ) {
cerr << üzenet << endl ;
}
Visszatérés 0 ;
}
Kimenet:
Az előzőleg nevezőként beszúrt szám „0”. Tehát a kivétel előfordul a kódban, és megjeleníti az adott üzenetet.
3. példa:
Itt jön létre a „szorzás()” függvény, amelyben az „int” adattípus paramétereiként az „értéket” és a „szorzót” helyezzük el. Ezután az „if”-t használjuk, amelyben hozzáadunk egy nullával egyenlő szorzófeltételt. Ezután a „dobás” szó kerül oda, ahol egy állítást adunk hozzá. Ezután megkapjuk a „return” értéket, ahol elhelyezzük a korábban deklarált „érték * szorzó” változókat. Tehát itt adja vissza a szorzás eredményét.
Ezután meghívjuk a „main()”-t, ahol az „int érték1” és „int érték2” értéket „34” és „0” értékkel deklaráljuk. Az „int m_res” is deklarálva van, majd itt „szorzás()” függvénynek nevezzük. A funkció végrehajtása után az eredmény mentésre kerül az „m_res” változóba, majd megjelenik. Ezt követően a „catch” funkciót alkalmazzuk, és beillesztjük a „const char* msg”-t, hogy megjelenítsük azt az üzenetet, amelyet korábban hozzáadtunk a „dobás” részhez.
3. kód:
#includesegítségével névtér std ;
kettős szorzás ( int érték, int szorzó ) {
ha ( szorzó == 0 ) {
dobás 'Nem szorozzuk meg az értéket nullával!' ;
}
Visszatérés ( érték * szorzó ) ;
}
int fő- ( ) {
int érték1 = 3. 4 ;
int érték2 = 0 ;
int m_res ;
próbáld ki {
m_res = szorzás ( érték1, érték2 ) ;
cout << m_res << endl ;
} fogás ( const char * üzenet ) {
cerr << üzenet << endl ;
}
Visszatérés 0 ;
}
Kimenet :
Mivel az általunk korábban beírt érték „0” a szorzója, a kódnak van egy kivétele, ami miatt itt jelenik meg a figyelmeztetés.
4. példa:
Itt felépítjük a „multiply()” függvényt, és átadjuk a „szám1” és „szám2” paramétereket az „int” adattípus paramétereiként. Ezután az „if” operátor segítségével adjunk hozzá egy feltételt, amely egy nullánál kisebb vagy azzal egyenlő szorzó. Ezt követően hozzá kell adni a kijelentést, ahol a „dobás” helye van. A szorzás eredményét ezután a „return” részben adjuk vissza, ahol beillesztjük a „szám1 * szám2” változót, amelyet korábban deklaráltunk.
Ezt követően meghívjuk a „main()” függvényt, és hozzárendeljük a „34” és „12” értékeket az „int newNumber1” és „int newNumber2” értékhez. Itt a „multiply()” függvény az „int mResult” deklarációja után kerül meghívásra. Most ennek a függvénynek az eredménye az „mResult” változóban kerül tárolásra, és a következőkben jelenik meg. Ezután a „catch” funkciót használjuk, és hozzáadjuk a „const char* msg”-t a „dobás” részben írt üzenet megjelenítéséhez.
4. kód:
#includesegítségével névtér std ;
kettős szaporodnak ( int number1 , int 2. számú ) {
ha ( 2. számú <= 0 ) {
dobás 'Nem szorozzuk meg az értéket nullával vagy negatív értékkel!' ;
}
Visszatérés ( szám1 * 2. számú ) ;
}
int fő- ( ) {
int newNum1 = 3. 4 ;
int newNum2 = 12 ;
int mEredmény ;
próbáld ki {
mEredmény = szaporodnak ( newNum1, newNum2 ) ;
cout << 'A szorzás eredménye' << mEredmény << endl ;
}
fogás ( const char * üzenet ) {
cerr << üzenet << endl ;
}
Visszatérés 0 ;
}
Kimenet:
A hozzáadott érték „12”, amelyhez hozzáadjuk a feltételt. Tehát a „multiply()” függvény végrehajtásra kerül, mivel a feltétel nem igaz. Megjelenik a szorzás eredménye. Itt kerül végrehajtásra a „próbálkozás” rész.
Következtetés
A „try-catch” koncepciót és az ebben az útmutatóban található kódokat részletesen tanulmányozzuk. Alaposan megvizsgáltuk ezt a „try-catch” koncepciót, és megmutattuk, hogyan működik a C++ programozásban. Meghatároztuk, hogy a „dobás” kifejezés kivételt hoz létre, ha olyan hibát találunk, amely lehetővé teszi egyedi kódunk megírását. A „catch” kifejezés használatával megadhatunk egy kódblokkot, amelyet le kell futtatni, ha kivétel jelenik meg a „try” részben.