Halimbawa 1:
Ang 'iostream' ay kasama dito, ang header file kung saan idineklara ang ilang mga function. Ginagamit namin ang mga function na ito na idineklara sa header file na ito sa aming code, kaya isinama namin ang header file na ito. Pagkatapos nito, mayroon kaming 'std' na nakalagay dito bilang mga function tulad ng 'cin' at 'cout' ay tinukoy din dito. Hindi namin kailangang i-type ang 'std' sa lahat ng mga function na ito kung idaragdag namin ang 'namespace std' sa simula ng aming code. Pagkatapos nito, ang function na 'main()' ay hinihimok dito na tinutukoy din bilang driver code ng C++ program.
Pagkatapos, ginagamit namin ang keyword na 'subukan' dito kung saan sinisimulan namin ang 'my_num1' gamit ang '35' na halaga. Ito ang 'int' na variable ng uri ng data dito. Ngayon, inilalagay namin ang variable na ito sa loob ng 'kung' at naglalagay ng kundisyon na nagsasabing ang 'my_num1' ay dapat na mas malaki sa o katumbas ng '98'. Kung ang ibinigay na kundisyon ay nasiyahan, ito ay nagpapatuloy sa loob ng 'kung' at isinasagawa ang pahayag na nakasulat dito. Ginagamit namin ang 'cout' at naglalagay ng mensaheng ipapakita kapag nasiyahan ang kundisyon.
Pagkatapos nito, ginagamit namin ang keyword na 'ihagis' pagkatapos ilagay ang 'iba'. Sa keyword na 'throw' na ito, ipinapasa namin ang 'my_num1' bilang parameter. Idinagdag namin ang bahaging 'catch' sa ibaba nito. Ipinasok namin ang 'my_num2' bilang parameter ng 'catch()' at pagkatapos ay gamitin muli ang 'cout' sa loob ng 'catch' na bahaging ito. Isinasagawa lamang ang bahaging ito kapag may naganap na pagbubukod sa bahaging 'subukan'.
Code 1:
#include
gamit namespace std ;
int pangunahing ( ) {
subukan {
int my_num1 = 35 ;
kung ( my_num1 >= 98 ) {
cout << 'Ibinigay ang Access dito.' ;
} iba pa {
itapon ( my_num1 ) ;
}
}
mahuli ( int my_num2 ) {
cout << 'Ang Access ay tinanggihan dito.' << endl ;
cout << 'Ang numero ay:' << my_num2 ;
}
bumalik 0 ;
}
Output:
Ang numerong ipinasok namin ay “35” na mas mababa sa “98”. Kaya, ang pagbubukod ay nangyayari doon at ang 'catch()' na bahagi ay ipinapakita. Ang pag-access sa bahaging 'subukan' ay tinanggihan.
Halimbawa 2:
Inilalagay namin ang 'iostream' na header file dito at ang 'namespace std'. Pagkatapos nito, gumawa kami ng function na 'division()' kung saan inilalagay namin ang dalawang parameter na 'numerator' at 'denominator' ng 'int' na uri ng data. Itinakda namin ang uri ng data ng function na 'division' na ito sa 'doble'.
Sa ibaba nito, idinaragdag namin ang 'if()' kung saan idinaragdag namin ang kundisyon na ang denominator ay katumbas ng zero. Pagkatapos nito, ginagamit namin ang keyword na 'ihagis' at nag-type ng mensahe doon. Ibinibigay ang mensaheng ito sa tuwing nangyayari ang pagbubukod sa code na ito ayon sa kundisyon. Sa ibaba nito, ginagamit namin ang keyword na 'return' kung saan inilalagay namin ang 'numerator/denominator'. Kaya, ibinabalik nito ang resulta ng paghahati. Ngayon, ang function na 'main()' ay tinatawag.
Pagkatapos nito, ang 'num1' at 'num2' ay sinisimulan bilang 'int' na mga variable at itinalaga ang '89' at '0' sa kanila ayon sa pagkakabanggit. Pagkatapos, sinisimulan namin ang 'resulta' ng 'double' na uri ng data. Dito, ginagamit namin ang keyword na 'subukan'. Sa bahaging ito, idinaragdag namin ang variable na 'resulta' na ito at itinatalaga ang function na 'division()' sa variable na ito. Ipinapasa namin ang dalawang parameter sa function na ito: 'num1' at 'num2'. Sa ibaba nito, ipinapakita namin ang 'resulta' na nakukuha namin pagkatapos ilapat ang function na 'division()'. Pagkatapos nito, ginagamit din namin ang 'catch' at ilagay ang 'const char* msg' upang ipakita ang mensahe na dati naming idinagdag.
Code 2:
#includegamit namespace std ;
doble dibisyon ( int numerator, int denominador ) {
kung ( denominador == 0 ) {
itapon 'Hindi pwede ang division by zero dito!' ;
}
bumalik ( numerator / denominador ) ;
}
int pangunahing ( ) {
int num1 = 89 ;
int num2 = 0 ;
doble resulta = 0 ;
subukan {
resulta = dibisyon ( num1, num2 ) ;
cout << resulta << endl ;
} mahuli ( const char * msg ) {
cerr << msg << endl ;
}
bumalik 0 ;
}
Output:
Ang numero na dati naming ipinasok bilang denominator ay “0”. Kaya, ang pagbubukod ay nangyayari sa code at ipinapakita nito ang ibinigay na mensahe.
Halimbawa 3:
Ang function na 'multiplication()' ay nilikha dito kung saan inilalagay namin ang 'value' at 'multiplier' bilang mga parameter ng 'int' na uri ng data. Pagkatapos, ginagamit namin ang 'kung' kung saan nagdaragdag kami ng kundisyon ng multiplier na katumbas ng zero. Pagkatapos, inilalagay ang 'ihagis' kung saan nagdaragdag kami ng isang pahayag. Pagkatapos, mayroon kaming 'return' kung saan inilalagay namin ang mga variable na 'value * multiplier' na dati naming idineklara. Kaya, ibinabalik nito ang resulta ng multiplikasyon dito.
Pagkatapos nito, tinatawag namin ang 'main()' kung saan ipinapahayag namin ang 'int value1' at 'int value2' na may mga value na '34' at '0', ayon sa pagkakabanggit. Ang 'int m_res' ay ipinahayag din at pagkatapos ay tinatawag na 'multiplication()' function dito. Pagkatapos isagawa ang function na ito, ang resulta ay nai-save na ngayon sa variable na 'm_res' at pagkatapos ay ipapakita. Kasunod nito, ginagamit namin ang function na 'catch' at ipinasok ang 'const char* msg' upang ipakita ang mensahe na idinagdag namin dati sa bahaging 'throw'.
Code 3:
#includegamit namespace std ;
doble pagpaparami ( int halaga, int multiplier ) {
kung ( multiplier == 0 ) {
itapon 'Hindi namin pinarami ang halaga ng zero!' ;
}
bumalik ( halaga * multiplier ) ;
}
int pangunahing ( ) {
int halaga1 = 3. 4 ;
int halaga2 = 0 ;
int m_res ;
subukan {
m_res = pagpaparami ( halaga1, halaga2 ) ;
cout << m_res << endl ;
} mahuli ( const char * msg ) {
cerr << msg << endl ;
}
bumalik 0 ;
}
Output :
Dahil ang value na dati naming inilagay ay may '0' bilang multiplier, ang code ay may exception na nagiging sanhi ng pagpapakita ng notice dito.
Halimbawa 4:
Dito, binubuo namin ang function na 'multiply()' at ipinapasa ang 'number1' at 'number2' bilang mga parameter ng uri ng data na 'int'. Susunod, ginagamit namin ang operator na 'kung' upang magdagdag ng isang kundisyon dito na isang multiplier na mas mababa sa o katumbas ng zero. Pagkatapos nito, idinagdag ang pahayag kung saan dapat na 'ihagis'. Ang resulta ng multiplikasyon ay ibabalik sa seksyong 'return' kung saan ipinapasok namin ang variable na 'number1 * number2' na dati naming idineklara.
Kasunod nito, ginagamit namin ang function na 'main()' at itinatalaga ang mga value na '34' at '12' sa 'int newNumber1' at 'int newNumber2', ayon sa pagkakabanggit. Dito, ang function na 'multiply()' ay tinatawag pagkatapos ng deklarasyon ng 'int mResult'. Ngayon, ang kinalabasan ng function na ito ay naka-imbak sa variable na 'mResult' at nai-render sa mga sumusunod. Pagkatapos ay ginagamit namin ang function na 'catch' at idagdag ang 'const char* msg' upang ipakita ang mensahe na isinulat namin sa seksyong 'throw'.
Code 4:
#includegamit namespace std ;
doble magparami ( int number1 , int numero2 ) {
kung ( numero2 <= 0 ) {
itapon 'Hindi namin i-multiply ang value na may zero o negatibong value!' ;
}
bumalik ( numero1 * numero2 ) ;
}
int pangunahing ( ) {
int bagongNum1 = 3. 4 ;
int bagongNum2 = 12 ;
int mResulta ;
subukan {
mResulta = magparami ( newNum1, newNum2 ) ;
cout << 'Ang resulta ng multiplikasyon ay' << mResulta << endl ;
}
mahuli ( const char * msg ) {
cerr << msg << endl ;
}
bumalik 0 ;
}
Output:
Ang value na idinaragdag namin ay '12' kung saan idinaragdag namin ang kundisyon. Kaya, ang function na 'multiply()' ay ginagawa dahil hindi totoo ang kundisyon. Ang resulta ng pagpaparami ay ipinapakita. Ang bahaging 'subukan' ay isinasagawa dito.
Konklusyon
Ang konsepto ng 'try-catch' at ang mga code sa gabay na ito ay pinag-aralan nang detalyado. Lubusan naming ginalugad ang konseptong 'try-catch' na ito at ipinakita kung paano ito gumagana sa C++ programming. Tinukoy namin na ang terminong 'throw' ay lumilikha ng isang pagbubukod kapag may nakitang error na nagbibigay-daan sa amin na isulat ang aming natatanging code. Gamit ang expression na 'catch', maaari naming tukuyin ang isang bloke ng code na tatakbo kung may lalabas na exception sa bahaging 'try'.