Voorbeeld 1: Programma om een aangepaste uitzonderingsklasse te maken in C++
Dit eenvoudige voorbeeld is geïmplementeerd om de aangepaste afhandeling en detectie van uitzonderingen in C++ te demonstreren.
#include#include
gebruik makend van naamruimte soa ;
klas DemoUitzondering : openbaar uitzondering
{
virtueel const verkoold * Wat ( ) const gooien ( )
{
opbrengst 'Aangepaste uitzondering vastgelegd' ;
}
} ;
int voornaamst ( )
{
DemoException dEx ;
poging
{
gooien dEx ;
}
vangst ( uitzondering & behalve )
{
uit << behalve. Wat ( ) << eindl ;
}
opbrengst 0 ;
}
We definiëren het headerbestand in de code, inclusief de “iostream” en “exception”. De “iostream” wordt specifiek aangeroepen voor de invoer- en uitvoerstroom, terwijl de “exception” -bibliotheek wordt aangeroepen om de uitzondering af te handelen. Hierna creëren we de klasse “DemoException” die is afgeleid van de klasse “exception” van C++. Hier stellen we de virtuele what()-functie in die wordt gebruikt om de const char* te leveren, die de resultaten weergeeft van een foutmelding die aan de uitzondering is gekoppeld.
Vervolgens roepen we een functie main() aan waarbij we het object “dEx” van de klasse “DemoException” maken. Daarna hebben we een ‘try’-blokdefinitie die de uitzondering genereert als deze wordt aangetroffen. Hier gooien we het object 'dEx'.
Vervolgens stellen we het ‘catch’-blok in om de uitzondering op te vangen en af te handelen. We geven de referentie van de klasse-uitzondering door als parameter om de uitzondering op te vangen die ervan is afgeleid. Binnen het blok “catch” roepen we de functie what() op “except” aan om het uitzonderingsbericht op de console te krijgen.
Na het uitvoeren van het gegeven programma wordt het aangepaste uitzonderingsbericht opgevangen en op de console weergegeven:
Voorbeeld 2: Programma om een aangepaste uitzondering te maken met behulp van twee klassen
Het programma legt de nadruk op het omgaan met meerdere uitzonderingen die onafhankelijk kunnen worden afgehandeld door meerdere klassen te definiëren.
#include
gebruik makend van naamruimte soa ;
klas evaluatie1 { } ;
klas evaluatie2 { } ;
int voornaamst ( ) {
poging {
gooien evaluatie1 ( ) ;
}
vangst ( evaluatie1 e ) {
uit << 'Evaluatie1 uitzondering gevangen!' << eindl ;
}
poging {
gooien evaluatie2 ( ) ;
}
vangst ( evaluatie2 e ) {
uit << 'Evaluatie 2 uitzondering Gevangen!' << eindl ;
}
opbrengst 0 ;
}
In de gegeven code hebben we de definitie van twee klassen, “Evaluatie1” en “Evaluatie2”, die nu leeg zijn. Daarna voeren we de main()-functie van het programma uit. Hier stellen we het try{}-blok in waarin het trefwoord “throw” wordt gebruikt om de instantie van de klasse “Evaluation1()” te genereren. Dit betekent dat de uitzondering “Evaluatie1” wordt gegenereerd als er een uitzondering optreedt in het programma binnen dit “try”-blok. Daarna hebben we een catch{}-blok waarin de uitzondering wordt opgevangen en het bericht van de uitzondering wordt weergegeven.
Op dezelfde manier hebben we een definitie van een ander try{}-blok voor de klasse “Evaluation2”. Binnen dat try{}-blok gooien we de instantie van de klasse “Evaluation2”. Dit genereert de uitzondering van “Evaluatie2” als hier een fout optreedt. Vervolgens roepen we het blok catch{} aan om het uitzonderingsbericht weer te geven met behulp van de opdracht “cout” als de uitzondering binnen dit blok wordt opgevangen.
De twee uitzonderingen op de verschillende “try-catch”-blokken worden in de console gegooid en worden door de twee verschillende klassen afgehandeld.
Voorbeeld 3: Programma om een aangepaste uitzondering te maken met Constructor
Het programma gebruikt de constructor voor het afhandelen van de uitzondering. Hoewel we de waarden niet van de constructor kunnen krijgen, kunnen we dit wel bereiken met behulp van het ‘try-catch’-blok.
#includegebruik makend van naamruimte soa ;
klas Test {
int val ;
openbaar :
Test ( int N )
{
poging {
als ( N == 0 )
val = N ;
weergave ( ) ;
}
vangst ( const verkoold * exp ) {
uit << 'Uitzondering gevonden \N ' ;
uit << exp << eindl ;
}
}
leegte weergave ( )
{
uit << 'Waarde = ' << val << eindl ;
}
} ;
int voornaamst ( )
{
Test ( 0 ) ;
uit << 'Er wordt opnieuw een instantie gemaakt \N ' ;
Test ( 1 ) ;
}
In de gegeven code vestigen we de klasse “Test” waarin de variabele wordt gedeclareerd als “val” van het type geheel getal. Vervolgens hebben we een definitie van de constructorfunctie “Test()” die wordt doorgegeven met de variabele “n”. Vervolgens stellen we het blok “try-catch” in binnen de constructorfunctie “Test()”. Het try-blok wordt aangeroepen met de if()-instructie. Als de waarde van “n” gelijk is aan nul, vangt het blok “catch” de uitzondering op en wordt het uitzonderingsbericht op de prompt weergegeven. De waarde van 'n' wordt opgeslagen in de variabele 'val' terwijl we deze initialiseren.
Daarna roepen we de functie display() aan om de waarde weer te geven die is opgeslagen in de variabele 'val'. Vervolgens hebben we de definitie van het “catch”-blok, waarbij de uitzondering die door het “try”-blok wordt gegenereerd, wordt afgehandeld. Ten slotte roepen we de functie main() aan. Daarbinnen noemen we de constructor 'Test()'. De constructor wordt geactiveerd wanneer het object van de klasse “Test()” wordt gemaakt en gespecificeerd met de waarde “0” waarop de uitzondering wordt gegenereerd.
Daarna roepen we de klasse “Test()” opnieuw aan om een instantie te maken die wordt doorgegeven met de waarde 1. Hier zal de constructor geen uitzondering genereren omdat de waarde niet gelijk is aan 0. De functie display() zal voer de waarde van 'val' uit en druk deze af.
De aangepaste uitzondering wordt op de console gegenereerd door de constructor aan te roepen. Wanneer aan de voorwaarde is voldaan, wordt de constructor ook zonder enige uitzondering uitgevoerd.
Voorbeeld 4: Programma om een door de gebruiker gedefinieerde aangepaste uitzondering te maken
Het programma verwerkt en ondervangt hier de uitzondering die door de gebruiker is gedefinieerd wanneer daarom wordt gevraagd in de prompt.
#include#include
gebruik makend van naamruimte soa ;
klas MijnDemo : openbaar uitzondering {
openbaar :
const verkoold * Wat ( ) const gooien ( )
{
opbrengst 'Uitzondering! Geprobeerd te delen door nul.! \N ' ;
}
} ;
int voornaamst ( )
{
poging
{
int n1, n2 ;
uit << 'Voer de twee gehele getallen in: \N ' ;
aan het eten >> n1 >> n2 ;
als ( n2 == 0 )
{
MijnDemo n3 ;
gooien n3 ;
}
anders
{
uit << 'n1/n2 = ' << n1 / n2 << eindl ;
}
}
vangst ( uitzondering & excl )
{
uit << excl. Wat ( ) ;
}
}
In de gegeven code definiëren we eerst de klasse “MyDemo()”, die de afhankelijke klasse van de uitzondering is. Daarna stellen we de openbare what()-functie in met het trefwoord ‘virtueel’. De functie what() wordt aangeroepen om de oorzaak van de uitzondering in het programma te achterhalen wanneer de functie throw() de uitzondering genereert. Vervolgens hebben we een main()-functie waarin de try-catch{}-blokken zijn gedefinieerd om de uitzondering te detecteren en af te handelen. Binnen het try{}-blok declareren we twee variabelen, “n1” en “n2”, waarvan de waarden van de gebruiker worden overgenomen met behulp van de opdracht “cin”. Wanneer de waarden voor elke “n1”- en “n2”-variabele worden ontvangen, controleert de “if”-voorwaarde of de “n2”-variabele gelijk is aan 0 of niet. Als dat het geval is, wordt er een uitzondering gegenereerd of worden de delingsresultaten geretourneerd. Ten slotte hebben we een catch{}-blok dat de referentie van de klasse “exception” als parameter neemt die ervan wordt geërfd.
De uitvoer laat zien wanneer niet aan de voorwaarde is voldaan en het programma zonder uitzondering wordt uitgevoerd:
We definiëren ook de waarde van “0” voor de variabele “n2” om weer te geven hoe de uitzondering wordt gegenereerd en opgevangen in het programma.
Conclusie
Concluderend hebben we het belangrijke concept van C++ gedemonstreerd, wat een uitzondering is. Een uitzondering belemmert de normale uitvoering van het programma. Hiervoor hebben we de trefwoorden ‘gooien’, ‘proberen’ en ‘vangen’ gebruikt om de uitzondering af te handelen die in het programma optreedt. We hebben deze trefwoorden in de voorgaande voorbeelden gebruikt om de uitzondering anders af te handelen.