Halimbawa 1: Programa para Gumawa ng Custom na Exception Class sa C++
Ang simpleng halimbawang ito ay ipinatupad upang ipakita ang custom na paghawak at pagtuklas ng exception sa C++.
#include#include
gamit namespace std ;
klase DemoException : pampubliko pagbubukod
{
virtual const char * Ano ( ) const itapon ( )
{
bumalik 'Nahuli ang Custom Exception' ;
}
} ;
int pangunahing ( )
{
DemoException dEx ;
subukan
{
itapon dEx ;
}
mahuli ( pagbubukod at maliban sa )
{
cout << maliban sa. Ano ( ) << endl ;
}
bumalik 0 ;
}
Tinukoy namin ang header file sa code kasama ang 'iostream' at 'exception'. Ang 'iostream' ay partikular na tinatawag para sa input at output stream, samantalang ang 'exception' na library ay tinawag upang hawakan ang exception. Pagkatapos nito, gagawa kami ng klase ng 'DemoException' na hinango mula sa klase ng 'exception' ng C++. Dito, itinakda namin ang virtual what() function na ginagamit upang magbigay ng const char* na nagpapakita ng mga resulta ng isang mensahe ng error na naka-link sa exception.
Pagkatapos, nag-invoke kami ng main() function kung saan ginagawa namin ang object na 'dEx' ng class na 'DemoException'. Pagkatapos nito, mayroon kaming 'subukan' na kahulugan ng bloke na nagtatapon ng pagbubukod kung nakatagpo. Dito, itinapon namin ang bagay na 'dEx'.
Susunod, itinakda namin ang 'catch' block upang mahuli ang exception at mahawakan ito. Ipinapasa namin ang sanggunian ng pagbubukod ng klase bilang isang parameter upang mahuli ang pagbubukod na nagmula rito. Sa loob ng 'catch' block, tinatawag namin ang what() function sa 'except' para makuha ang exception message sa console.
Pagkatapos isagawa ang ibinigay na programa, ang pasadyang mensahe ng pagbubukod ay nakuha at itinapon sa console:
Halimbawa 2: Programa para Gumawa ng Custom Exception Gamit ang Dalawang Klase
Binibigyang-diin ng programa ang pagharap sa maraming mga pagbubukod na maaaring pangasiwaan nang nakapag-iisa sa pamamagitan ng pagtukoy ng maraming klase.
#include
gamit namespace std ;
klase pagsusuri1 { } ;
klase pagsusuri2 { } ;
int pangunahing ( ) {
subukan {
itapon pagsusuri1 ( ) ;
}
mahuli ( pagsusuri1 e ) {
cout << 'Nahuli ang Evaluation1 exception!' << endl ;
}
subukan {
itapon pagsusuri2 ( ) ;
}
mahuli ( pagsusuri2 e ) {
cout << 'Evaluation 2 exception Caught!' << endl ;
}
bumalik 0 ;
}
Sa ibinigay na code, mayroon kaming kahulugan ng dalawang klase, 'Evaluation1' at 'Evaluation2', na ngayon ay walang laman. Pagkatapos nito, isinasagawa namin ang pangunahing() function ng programa. Dito, itinakda namin ang try{} block kung saan ginagamit ang 'throw' na keyword upang ihagis ang instance ng 'Evaluation1()' na klase. Ito ay kumakatawan na ang 'Evaluation1' exception ay itinapon kung anumang exception ang lumitaw sa programa sa loob ng 'try' block na ito. Pagkatapos nito, mayroon kaming catch{} block kung saan nakukuha ang exception at ipinapakita ang mensahe ng exception.
Katulad nito, mayroon kaming kahulugan ng isa pang try{} block para sa klase ng “Evaluation2”. Sa loob ng try{} block na iyon, itinapon namin ang instance ng klase ng 'Evaluation2'. Itinapon nito ang pagbubukod ng 'Evaluation2' kung may naganap na error dito. Pagkatapos, tinatawagan namin ang catch{} block upang ipakita ang exception message gamit ang command na 'cout' kung ang exception ay nakuha sa loob ng block na ito.
Ang dalawang pagbubukod ng magkaibang 'try-catch' na mga bloke ay itinapon sa console na pinangangasiwaan ng dalawang magkaibang klase.
Halimbawa 3: Programa para Gumawa ng Custom na Exception sa Constructor
Ginagamit ng programa ang constructor para sa paghawak ng exception. Kahit na hindi namin makuha ang mga halaga mula sa constructor, maaari naming makamit ito gamit ang 'try-catch' block.
#includegamit namespace std ;
klase Pagsusulit {
int val ;
pampubliko :
Pagsusulit ( int n )
{
subukan {
kung ( n == 0 )
val = n ;
display ( ) ;
}
mahuli ( const char * exp ) {
cout << 'Nakahanap ng exception \n ' ;
cout << exp << endl ;
}
}
walang bisa display ( )
{
cout << 'Halaga = ' << val << endl ;
}
} ;
int pangunahing ( )
{
Pagsusulit ( 0 ) ;
cout << 'Gumawa ulit ng instance \n ' ;
Pagsusulit ( 1 ) ;
}
Sa ibinigay na code, itinatatag namin ang klase ng 'Pagsubok' kung saan ang variable ay idineklara bilang 'val' ng uri ng integer. Pagkatapos, mayroon kaming isang kahulugan ng 'Test()' constructor function na ipinasa kasama ang 'n' variable. Pagkatapos ay itinakda namin ang 'try-catch' block sa loob ng 'Test()' constructor function. Ang try block ay tinatawag na may if() statement. Kung ang halaga ng 'n' ay katumbas ng zero, ang 'catch' block ay kukuha ng exception, at ang exception na mensahe ay ihahagis sa prompt. Ang halaga ng 'n' ay naka-imbak sa 'val' na variable habang sinisimulan namin ito.
Pagkatapos nito, tinatawagan namin ang display() function upang ipakita ang halaga na nakaimbak sa variable na 'val'. Susunod, mayroon kaming kahulugan ng 'catch' block kung saan ang exception na itinapon ng 'try' block ay pinangangasiwaan. Sa wakas, hinihiling namin ang main() function. Sa loob nito, tinatawag namin ang 'Test()'constructor. Ang constructor ay na-trigger kapag ang object ng 'Test()' class ay ginawa at tinukoy na may halagang '0' kung saan ang exception ay itinapon.
Pagkatapos nito, tinatawagan naming muli ang klase na 'Test()' upang lumikha ng isang instance na ipinasa na may halaga na 1. Dito, hindi magtapon ng anumang exception ang constructor dahil ang value ay hindi katumbas ng 0. Ang display() function ay isagawa at i-print ang halaga ng “val”.
Ang custom na exception ay itinapon sa console sa pamamagitan ng pagtawag sa constructor. Gayundin, kapag ang kondisyon ay nasiyahan, ang constructor ay nagsasagawa nang walang anumang pagbubukod.
Halimbawa 4: Programa para Gumawa ng Custom Exception na Tinukoy ng User
Ang program dito ay humahawak at nakakakuha ng exception na tinukoy ng user kapag tinanong sa prompt.
#include#include
gamit namespace std ;
klase MyDemo : pampubliko pagbubukod {
pampubliko :
const char * Ano ( ) const itapon ( )
{
bumalik 'Exception! Sinubukan ang paghahati sa zero.! \n ' ;
}
} ;
int pangunahing ( )
{
subukan
{
int n1, n2 ;
cout << 'Ipasok ang dalawang integer: \n ' ;
kumakain >> n1 >> n2 ;
kung ( n2 == 0 )
{
MyDemo n3 ;
itapon n3 ;
}
iba pa
{
cout << 'n1/n2 = ' << n1 / n2 << endl ;
}
}
mahuli ( pagbubukod at exc )
{
cout << exc. Ano ( ) ;
}
}
Sa ibinigay na code, una naming tinukoy ang 'MyDemo()' na klase na siyang umaasa sa klase ng exception. Pagkatapos nito, itinakda namin ang pampublikong what() function na may 'virtual' na keyword. Tinatawag ang what() function upang makuha ang sanhi ng exception sa program kapag ang throw() function ay naghagis ng exception. Pagkatapos, mayroon kaming main() function kung saan ang try-catch{} na mga bloke ay tinukoy upang makita at mahawakan ang exception. Sa loob ng try{} block, nagdedeklara kami ng dalawang variable, 'n1' at 'n2', na ang mga value ay kinuha mula sa user gamit ang command na 'cin'. Kapag natanggap ang mga halaga laban sa bawat variable na 'n1' at 'n2', susuriin ng kundisyon na 'kung' kung ang variable na 'n2' ay katumbas ng 0 o hindi. Kung gayon, ang isang pagbubukod ay itinapon o ang mga resulta ng paghahati ay ibabalik. Panghuli, mayroon kaming catch{} block na kumukuha ng reference ng class na 'exception' bilang isang parameter na minana mula rito.
Ang output ay nagpapakita kapag ang kundisyon ay hindi natugunan at ang programa ay naisakatuparan nang walang pagbubukod:
Gayundin, tinukoy namin ang halaga ng '0' sa variable na 'n2' upang kumatawan kung paano itinapon at nahuhuli ang pagbubukod sa programa.
Konklusyon
Sa konklusyon, ipinakita namin ang mahalagang konsepto ng C++ na isang exception. Ang isang pagbubukod ay humahadlang sa regular na pagpapatupad ng programa. Para dito, ginamit namin ang mga keyword na 'throw', 'try', at 'catch' para mahawakan ang exception na nangyayari sa program. Ginamit namin ang mga keyword na ito sa mga nakaraang halimbawa upang pangasiwaan ang exception sa ibang paraan.