Exemplul 1:
Aici este inclus „iostream”, fișierul antet în care sunt declarate mai multe funcții. Folosim aceste funcții care sunt declarate în acest fișier antet în codul nostru, așa că includem acest fișier antet. După aceasta, avem „std” care este plasat aici, deoarece funcții precum „cin” și „cout” sunt, de asemenea, definite în el. Nu trebuie să introducem „std” cu toate aceste funcții dacă adăugăm „namespace std” la începutul codului nostru. După aceasta, funcția „main()” este invocată aici, care este denumită și codul de driver al programului C++.
Apoi, folosim cuvântul cheie „încercați” aici, în care inițializam „my_num1” cu valoarea „35”. Aici este variabila tip de date „int”. Acum, plasăm această variabilă în „dacă” și plasăm o condiție care spune că „my_num1” trebuie să fie mai mare sau egal cu „98”. Dacă condiția dată este îndeplinită, se deplasează înainte în interiorul „dacă” și execută instrucțiunea care este scrisă aici. Utilizăm „cout” și introducem un mesaj pentru a afișa atunci când condiția este îndeplinită.
După aceasta, folosim cuvântul cheie „aruncă” după ce plasăm „altfel”. În acest cuvânt cheie „aruncă”, trecem „my_num1” ca parametru. Adăugăm partea „captură” sub aceasta. Inserăm „my_num2” ca parametru al „catch()” și apoi folosim din nou „cout” în interiorul acestei părți „catch”. Această parte se execută numai atunci când apare o excepție în partea „încercați”.
Cod 1:
#include
folosind spatiu de nume std ;
int principal ( ) {
încerca {
int my_num1 = 35 ;
dacă ( my_num1 >= 98 ) {
cout << „Accesul este permis aici”. ;
} altfel {
arunca ( my_num1 ) ;
}
}
captură ( int my_num2 ) {
cout << „Accesul este interzis aici”. << endl ;
cout << „Numărul este:” << my_num2 ;
}
întoarcere 0 ;
}
Ieșire:
Numărul pe care l-am introdus este „35”, care este mai mic decât „98”. Deci, excepția apare acolo și este afișată partea „catch()”. Accesul la partea „încercați” este interzis.
Exemplul 2:
Plasăm aici fișierul antet „iostream” și „namespace std”. După aceasta, creăm o funcție „division()” în care plasăm doi parametri care sunt „numeratorul” și „numitorul” tipului de date „int”. Am setat tipul de date al acestei funcții de „diviziune” la „dublu”.
Sub aceasta, adăugăm „dacă()” în care adăugăm condiția ca numitorul să fie egal cu zero. După aceasta, folosim cuvântul cheie „aruncă” și introducem un mesaj acolo. Acest mesaj este redat ori de câte ori apare o excepție în acest cod în funcție de condiție. Sub acesta, folosim cuvântul cheie „întoarcere” în care plasăm „numerator/numitor”. Deci, returnează rezultatul împărțirii. Acum, funcția „main()” este apelată.
După aceasta, „num1” și „num2” sunt inițializate ca variabile „int” și le atribuie „89” și, respectiv, „0”. Apoi, inițializam „rezultatul” tipului de date „dublu”. Aici, folosim cuvântul cheie „încercați”. În această parte, adăugăm această variabilă „rezultat” și atribuim funcția „diviziune()” acestei variabile. Transmitem doi parametri acestei funcții: „num1” și „num2”. Sub acesta, afișăm „rezultatul” pe care îl obținem după aplicarea funcției „diviziune()”. După aceasta, folosim și „catch” și plasăm „const char* msg” pentru a afișa mesajul pe care l-am adăugat anterior.
Cod 2:
#includefolosind spatiu de nume std ;
dubla Divizia ( int numărător, int numitor ) {
dacă ( numitor == 0 ) {
arunca „Diviziunea la zero nu este posibilă aici!” ;
}
întoarcere ( numărător / numitor ) ;
}
int principal ( ) {
int num1 = 89 ;
int num2 = 0 ;
dubla rezultat = 0 ;
încerca {
rezultat = Divizia ( num1, num2 ) ;
cout << rezultat << endl ;
} captură ( const char * msg ) {
cerr << msg << endl ;
}
întoarcere 0 ;
}
Ieșire:
Numărul pe care l-am introdus anterior ca numitor este „0”. Deci, excepția apare în cod și afișează mesajul dat.
Exemplul 3:
Aici este creată funcția „multiplication()” în care plasăm „valoarea” și „multiplicatorul” ca parametri ai tipului de date „int”. Apoi, folosim „dacă” în care adăugăm o condiție de multiplicare care este egală cu zero. Apoi, „aruncare” este plasat acolo unde adăugăm o declarație. Apoi, avem „întoarcerea” unde plasăm variabilele „valoare * multiplicator” pe care le-am declarat anterior. Deci, returnează rezultatul înmulțirii aici.
După aceasta, numim „main()” unde declarăm „int value1” și „int value2” cu valorile „34” și respectiv „0”. „int m_res” este de asemenea declarată și apoi numită funcția „multiplication()” aici. După efectuarea acestei funcții, rezultatul este acum salvat în variabila „m_res” și apoi afișat. Ulterior, folosim funcția „catch” și inserăm „const char* msg” pentru a afișa mesajul pe care l-am adăugat anterior în partea „throw”.
Cod 3:
#includefolosind spatiu de nume std ;
dubla multiplicare ( int valoare, int multiplicator ) {
dacă ( multiplicator == 0 ) {
arunca „Nu înmulțim valoarea cu zero!” ;
}
întoarcere ( valoare * multiplicator ) ;
}
int principal ( ) {
int valoare1 = 3. 4 ;
int valoarea2 = 0 ;
int m_res ;
încerca {
m_res = multiplicare ( valoare1, valoare2 ) ;
cout << m_res << endl ;
} captură ( const char * msg ) {
cerr << msg << endl ;
}
întoarcere 0 ;
}
Ieșire :
Deoarece valoarea pe care am introdus-o anterior are „0” ca multiplicator, codul are o excepție care face ca notificarea să fie afișată aici.
Exemplul 4:
Aici, construim funcția „multiply()” și trecem „number1” și „number2” ca parametri ai tipului de date „int”. Apoi, folosim operatorul „dacă” pentru a-i adăuga o condiție care este un multiplicator care este mai mic sau egal cu zero. După aceea, se adaugă declarația acolo unde ar trebui să fie „aruncare”. Rezultatul înmulțirii este apoi returnat în secțiunea „return” unde inserăm variabila „number1 * number2” pe care am declarat-o anterior.
Ulterior, invocăm funcția „main()” și atribuim valorile „34” și „12” la „int newNumber1” și, respectiv, „int newNumber2”. Aici, funcția „multiply()” este apelată după declararea „int mResult”. Acum, rezultatul acestei funcții este stocat în variabila „mResult” și este redat în cele ce urmează. Folosim apoi funcția „catch” și adăugăm „const char* msg” pentru a afișa mesajul pe care l-am scris în secțiunea „throw”.
Cod 4:
#includefolosind spatiu de nume std ;
dubla multiplica ( int Numărul 1 , int numarul 2 ) {
dacă ( numarul 2 <= 0 ) {
arunca „Nu înmulțim valoarea cu zero sau cu valoare negativă!” ;
}
întoarcere ( Numărul 1 * numarul 2 ) ;
}
int principal ( ) {
int nouNumăr1 = 3. 4 ;
int nouNum2 = 12 ;
int mRezultat ;
încerca {
mRezultat = multiplica ( newNum1, newNum2 ) ;
cout << „Rezultatul înmulțirii este” << mRezultat << endl ;
}
captură ( const char * msg ) {
cerr << msg << endl ;
}
întoarcere 0 ;
}
Ieșire:
Valoarea pe care o adăugăm este „12” la care adăugăm condiția. Deci, funcția „multiplicare()” este efectuată deoarece condiția nu este adevărată. Se afișează rezultatul înmulțirii. Partea „încercați” este executată aici.
Concluzie
Conceptul „try-catch” și codurile din acest ghid sunt studiate în detaliu. Am explorat în detaliu acest concept „try-catch” și am arătat cum funcționează în programarea C++. Am definit că termenul „aruncare” creează o excepție atunci când este găsită o eroare care ne permite să scriem codul nostru unic. Folosind expresia „catch”, putem specifica un bloc de cod care urmează să fie rulat dacă apare o excepție în partea „try”.