Eksempel 1: Program for å opprette en tilpasset unntaksklasse i C++
Dette enkle eksemplet er implementert for å demonstrere tilpasset unntakshåndtering og deteksjon i C++.
#include#inkluder
ved hjelp av navneområde std ;
klasse DemoException : offentlig unntak
{
virtuell konst røye * hva ( ) konst kaste ( )
{
komme tilbake 'Fanget tilpasset unntak' ;
}
} ;
int hoved- ( )
{
DemoException dEx ;
prøve
{
kaste dEx ;
}
å fange ( unntak & unntatt )
{
cout << unntatt. hva ( ) << endl ;
}
komme tilbake 0 ;
}
Vi definerer overskriftsfilen i koden inkludert 'iostream' og 'unntak'. 'iostream' kalles spesifikt for inngangs- og utgangsstrømmen, mens 'unntak'-biblioteket kalles ut for å håndtere unntaket. Etter dette lager vi 'DemoException'-klassen som er avledet fra 'exception'-klassen til C++. Her setter vi den virtuelle what()-funksjonen som brukes til å gi const char* som viser resultatene av en feilmelding som er knyttet til unntaket.
Deretter påkaller vi en hoved()-funksjon der vi lager 'dEx'-objektet til klassen 'DemoException'. Etter det har vi en 'prøve' blokkdefinisjon som kaster unntaket hvis det oppstår. Her kaster vi 'dEx'-objektet.
Deretter setter vi 'fangst'-blokken for å fange unntaket og håndtere det. Vi sender referansen til klasseunntaket som en parameter for å fange opp unntaket som er avledet fra det. Inne i 'catch'-blokken kaller vi what()-funksjonen på 'except' for å få unntaksmeldingen på konsollen.
Etter å ha kjørt det gitte programmet, blir den tilpassede unntaksmeldingen fanget og kastet på konsollen:
Eksempel 2: Program for å lage et tilpasset unntak ved bruk av to klasser
Programmet legger vekt på å håndtere flere unntak som kan håndteres uavhengig ved å definere flere klasser.
#include
ved hjelp av navneområde std ;
klasse evaluering 1 { } ;
klasse evaluering 2 { } ;
int hoved- ( ) {
prøve {
kaste evaluering 1 ( ) ;
}
å fange ( evaluering1 e ) {
cout << 'Evaluering 1 unntak fanget!' << endl ;
}
prøve {
kaste evaluering 2 ( ) ;
}
å fange ( evaluering2 e ) {
cout << 'Evaluering 2 unntak fanget!' << endl ;
}
komme tilbake 0 ;
}
I den gitte koden har vi definisjonen av to klasser, 'Evaluering1' og 'Evaluering2', som nå er tomme. Etter det utfører vi programmets hoved()-funksjon. Her setter vi try{}-blokken der «throw»-nøkkelordet brukes til å kaste forekomsten av «Evaluation1()»-klassen. Dette representerer at 'Evaluation1'-unntaket blir kastet hvis det oppstår unntak i programmet innenfor denne 'prøve'-blokken. Etter det har vi en catch{}-blokk der unntaket fanges opp og viser meldingen om unntaket.
På samme måte har vi en definisjon av en annen prøve{}-blokk for 'Evaluation2'-klassen. Inne i den try{}-blokken kaster vi forekomsten av klassen 'Evaluation2'. Dette gir unntaket 'Evaluering2' hvis det oppstår en feil her. Deretter kaller vi catch{}-blokken for å vise unntaksmeldingen ved å bruke 'cout'-kommandoen hvis unntaket er fanget innenfor denne blokken.
De to unntakene av de forskjellige 'prøve-fangst'-blokkene blir kastet i konsollen som håndteres av de to forskjellige klassene.
Eksempel 3: Program for å lage et tilpasset unntak med Constructor
Programmet bruker konstruktøren for å håndtere unntaket. Selv om vi ikke kan få verdiene fra konstruktøren, kan vi oppnå dette ved å bruke 'try-catch'-blokken.
#includeved hjelp av navneområde std ;
klasse Test {
int val ;
offentlig :
Test ( int n )
{
prøve {
hvis ( n == 0 )
val = n ;
vise ( ) ;
}
å fange ( konst røye * exp ) {
cout << 'Unntak funnet \n ' ;
cout << exp << endl ;
}
}
tomrom vise ( )
{
cout << 'Verdi = ' << val << endl ;
}
} ;
int hoved- ( )
{
Test ( 0 ) ;
cout << 'Oppretter instans igjen \n ' ;
Test ( 1 ) ;
}
I den gitte koden etablerer vi 'Test'-klassen der variabelen er deklarert som 'val' av typen heltall. Deretter har vi en definisjon av 'Test()'-konstruktørfunksjonen som sendes med 'n'-variabelen. Vi setter deretter 'try-catch'-blokken i 'Test()'-konstruktørfunksjonen. Try-blokken kalles med if()-setningen. Hvis verdien av 'n' er lik null, vil 'fangst'-blokken fange unntaket, og unntaksmeldingen vil bli kastet på ledeteksten. Verdien av 'n' lagres i 'val'-variabelen når vi initialiserer den.
Etter det kaller vi display()-funksjonen for å vise verdien som er lagret i 'val'-variabelen. Deretter har vi definisjonen av 'fangst'-blokken der unntaket som blir kastet av 'prøve'-blokken håndteres. Til slutt påkaller vi hoved()-funksjonen. Inni som kaller vi 'Test()'-konstruktøren. Konstruktøren utløses når objektet til 'Test()'-klassen opprettes og spesifiseres med verdien '0' som unntaket blir kastet på.
Deretter kaller vi 'Test()'-klassen igjen for å lage en instans som er bestått med verdien 1. Her vil ikke konstruktøren gi noe unntak siden verdien ikke er lik 0. Display()-funksjonen vil kjør og skriv ut verdien av «val».
Det tilpassede unntaket blir kastet på konsollen ved å ringe konstruktøren. Dessuten, når betingelsen er oppfylt, kjører konstruktøren uten unntak.
Eksempel 4: Program for å opprette et brukerdefinert tilpasset unntak
Programmet her håndterer og fanger opp unntaket som er definert av brukeren når det blir spurt i ledeteksten.
#include#inkluder
ved hjelp av navneområde std ;
klasse Min Demo : offentlig unntak {
offentlig :
konst røye * hva ( ) konst kaste ( )
{
komme tilbake 'Unntak! Prøvde å dele på null.! \n ' ;
}
} ;
int hoved- ( )
{
prøve
{
int n1, n2 ;
cout << 'Skriv inn de to heltallene: \n ' ;
spiser >> n1 >> n2 ;
hvis ( n2 == 0 )
{
MyDemo n3 ;
kaste n3 ;
}
ellers
{
cout << 'n1/n2 = ' << n1 / n2 << endl ;
}
}
å fange ( unntak & eks )
{
cout << eks. hva ( ) ;
}
}
I den gitte koden definerer vi først 'MyDemo()'-klassen som er den avhengige klassen for unntaket. Etter det setter vi den offentlige what()-funksjonen med det 'virtuelle' søkeordet. What()-funksjonen kalles ut for å få årsaken til unntaket i programmet når throw()-funksjonen kaster unntaket. Deretter har vi en main()-funksjon der try-catch{}-blokkene er definert for å oppdage og håndtere unntaket. Innenfor try{}-blokken erklærer vi to variabler, 'n1' og 'n2', hvis verdier er hentet fra brukeren ved å bruke 'cin'-kommandoen. Når verdiene mot hver 'n1'- og 'n2'-variabel mottas, vil 'if'-betingelsen sjekke om 'n2'-variabelen er lik 0 eller ikke. I så fall blir et unntak kastet eller divisjonsresultatene returnert. Til slutt har vi en catch{}-blokk som tar referansen til 'exception'-klassen som en parameter arvet fra den.
Utdataene viser når betingelsen ikke er oppfylt og programmet kjøres uten unntak:
Vi definerer også verdien av '0' til 'n2'-variabelen for å representere hvordan unntaket blir kastet og fanget i programmet.
Konklusjon
Avslutningsvis demonstrerte vi det viktige konseptet C++ som er et unntak. Et unntak hindrer programmets vanlige kjøring. For dette brukte vi søkeordene 'kast', 'prøve' og 'fang' for å håndtere unntaket som skjer i programmet. Vi brukte disse nøkkelordene i de forrige eksemplene for å håndtere unntaket annerledes.