Eksempel 1: Program til at oprette en brugerdefineret undtagelsesklasse i C++
Dette simple eksempel er implementeret for at demonstrere den brugerdefinerede undtagelseshåndtering og detektion i C++.
#include#inkluder
ved brug af navneområde std ;
klasse DemoException : offentlig undtagelse
{
virtuelle konst char * hvad ( ) konst kaste ( )
{
Vend tilbage 'Fanget tilpasset undtagelse' ;
}
} ;
int vigtigste ( )
{
DemoException dEx ;
prøve
{
kaste dEx ;
}
fangst ( undtagelse & undtagen )
{
cout << undtagen. hvad ( ) << endl ;
}
Vend tilbage 0 ;
}
Vi definerer header-filen i koden inklusive 'iostream' og 'undtagelse'. 'iostream' kaldes specifikt for input- og outputstrømmen, mens 'exception'-biblioteket kaldes ud for at håndtere undtagelsen. Efter dette opretter vi 'DemoException'-klassen, der er afledt af 'exception'-klassen i C++. Her indstiller vi den virtuelle what() funktion, der bruges til at give const char*, som viser resultaterne af en fejlmeddelelse, der er knyttet til undtagelsen.
Derefter kalder vi en main() funktion, hvor vi opretter 'dEx' objektet i klassen 'DemoException'. Derefter har vi en 'prøv' blokdefinition, som kaster undtagelsen, hvis den støder på. Her kaster vi 'dEx' objektet.
Dernæst indstiller vi 'fangst'-blokken til at fange undtagelsen og håndtere den. Vi videregiver referencen til klasseundtagelsen som en parameter for at fange den undtagelse, der er afledt af den. Inde i 'catch'-blokken kalder vi what()-funktionen på 'except' for at få undtagelsesmeddelelsen på konsollen.
Efter eksekvering af det givne program fanges den brugerdefinerede undtagelsesmeddelelse og smides på konsollen:
Eksempel 2: Program til at oprette en brugerdefineret undtagelse ved hjælp af to klasser
Programmet lægger vægt på at håndtere flere undtagelser, der kan håndteres uafhængigt ved at definere flere klasser.
#include
ved brug af navneområde std ;
klasse evaluering 1 { } ;
klasse evaluering 2 { } ;
int vigtigste ( ) {
prøve {
kaste evaluering 1 ( ) ;
}
fangst ( evaluering1 e ) {
cout << 'Evaluering 1 undtagelse fanget!' << endl ;
}
prøve {
kaste evaluering 2 ( ) ;
}
fangst ( evaluering2 e ) {
cout << 'Evaluering 2 undtagelse fanget!' << endl ;
}
Vend tilbage 0 ;
}
I den givne kode har vi definitionen af to klasser, 'Evaluation1' og 'Evaluation2', som nu er tomme. Derefter udfører vi programmets hoved() funktion. Her indstiller vi try{}-blokken, hvor 'throw'-søgeordet bruges til at kaste instansen af 'Evaluation1()'-klassen. Dette repræsenterer, at 'Evaluation1'-undtagelsen kastes, hvis der opstår en undtagelse i programmet inde i denne 'prøv'-blok. Derefter har vi en catch{}-blok, hvor undtagelsen fanges og viser meddelelsen om undtagelsen.
På samme måde har vi en definition af en anden try{}-blok for klassen 'Evaluation2'. Inden i den prøve{}-blok smider vi forekomsten af klassen 'Evaluation2'. Dette kaster undtagelsen af 'Evaluering2', hvis der opstår en fejl her. Derefter kalder vi catch{}-blokken for at vise undtagelsesmeddelelsen ved hjælp af 'cout'-kommandoen, hvis undtagelsen er fanget inden for denne blok.
De to undtagelser af de forskellige 'try-catch' blokke er smidt i konsollen, som håndteres af de to forskellige klasser.
Eksempel 3: Program til at oprette en brugerdefineret undtagelse med Constructor
Programmet bruger konstruktøren til at håndtere undtagelsen. Selvom vi ikke kan få værdierne fra konstruktøren, kan vi opnå dette ved at bruge 'try-catch'-blokken.
#includeved brug af navneområde std ;
klasse Prøve {
int val ;
offentlig :
Prøve ( int n )
{
prøve {
hvis ( n == 0 )
val = n ;
Skærm ( ) ;
}
fangst ( konst char * eksp ) {
cout << 'undtagelse fundet \n ' ;
cout << eksp << endl ;
}
}
ugyldig Skærm ( )
{
cout << 'Værdi = ' << val << endl ;
}
} ;
int vigtigste ( )
{
Prøve ( 0 ) ;
cout << 'Opretter instans igen \n ' ;
Prøve ( 1 ) ;
}
I den givne kode etablerer vi klassen 'Test', hvor variablen er erklæret som 'val' af typen heltal. Derefter har vi en definition af 'Test()'-konstruktørfunktionen, som sendes med variablen 'n'. Vi indstiller derefter 'try-catch'-blokken i 'Test()'-konstruktørfunktionen. Try-blokken kaldes med if()-sætningen. Hvis værdien af 'n' er lig med nul, vil 'fangst'-blokken fange undtagelsen, og undtagelsesmeddelelsen vil blive kastet på prompten. Værdien af 'n' gemmes i 'val'-variablen, når vi initialiserer den.
Derefter kalder vi display()-funktionen for at vise den værdi, der er gemt i 'val'-variablen. Dernæst har vi definitionen af 'fangst'-blokken, hvor undtagelsen, der kastes af 'forsøg'-blokken, håndteres. Til sidst kalder vi hoved()-funktionen. Indeni kalder vi 'Test()'-konstruktøren. Konstruktøren udløses, når objektet i klassen 'Test()' oprettes og specificeres med værdien '0', som undtagelsen er kastet på.
Derefter kalder vi 'Test()'-klassen igen for at skabe en instans, der er bestået med værdien 1. Her vil konstruktøren ikke kaste nogen undtagelse, da værdien ikke er lig med 0. Display()-funktionen vil udfør og udskriv værdien af 'val'.
Den brugerdefinerede undtagelse kastes på konsollen ved at kalde konstruktøren. Når betingelsen er opfyldt, udfører konstruktøren også uden undtagelse.
Eksempel 4: Program til at oprette en brugerdefineret brugerdefineret undtagelse
Programmet her håndterer og fanger undtagelsen, som er defineret af brugeren, når du bliver spurgt i prompten.
#include#inkluder
ved brug af navneområde std ;
klasse Min Demo : offentlig undtagelse {
offentlig :
konst char * hvad ( ) konst kaste ( )
{
Vend tilbage 'Undtagelse! Forsøgte at dividere med nul.! \n ' ;
}
} ;
int vigtigste ( )
{
prøve
{
int n1, n2 ;
cout << 'Indtast de to heltal: \n ' ;
spise >> n1 >> n2 ;
hvis ( n2 == 0 )
{
Min Demo n3 ;
kaste n3 ;
}
andet
{
cout << 'n1/n2 = ' << n1 / n2 << endl ;
}
}
fangst ( undtagelse & eks )
{
cout << eks. hvad ( ) ;
}
}
I den givne kode definerer vi først klassen 'MyDemo()', som er den afhængige klasse for undtagelsen. Derefter indstiller vi den offentlige what()-funktion med det 'virtuelle' søgeord. What()-funktionen kaldes ud for at få årsagen til undtagelsen i programmet, når throw()-funktionen kaster undtagelsen. Derefter har vi en main()-funktion, hvor try-catch{}-blokkene er defineret til at detektere og håndtere undtagelsen. Indenfor try{}-blokken erklærer vi to variable, 'n1' og 'n2', hvis værdier tages fra brugeren ved hjælp af 'cin'-kommandoen. Når værdierne mod hver 'n1'- og 'n2'-variable modtages, vil 'hvis'-betingelsen kontrollere, om 'n2'-variablen er lig med 0 eller ej. Hvis det er tilfældet, kastes en undtagelse, eller divisionsresultaterne returneres. Til sidst har vi en catch{}-blok, som tager referencen til 'exception'-klassen som en parameter, der er nedarvet fra den.
Outputtet viser, når betingelsen er uopfyldt, og programmet køres uden undtagelse:
Vi definerer også værdien af '0' til 'n2'-variablen for at repræsentere, hvordan undtagelsen kastes og fanges i programmet.
Konklusion
Afslutningsvis demonstrerede vi det vigtige koncept med C++, som er en undtagelse. En undtagelse hindrer programmets regelmæssige udførelse. Til dette brugte vi nøgleordene 'kast', 'prøv' og 'fang' til at håndtere den undtagelse, der sker i programmet. Vi brugte disse nøgleord i de foregående eksempler for at håndtere undtagelsen anderledes.