Esempio 1: programma per creare una classe di eccezioni personalizzata in C++
Questo semplice esempio viene implementato per dimostrare la gestione e il rilevamento personalizzati delle eccezioni in C++.
#include#include
utilizzando spazio dei nomi standard ;
classe DemoException : pubblico eccezione
{
virtuale cost car * Che cosa ( ) cost gettare ( )
{
ritorno 'Eccezione personalizzata rilevata' ;
}
} ;
int principale ( )
{
DemoException dEx ;
Tentativo
{
gettare dEx ;
}
presa ( eccezione & tranne )
{
cout << tranne. Che cosa ( ) << fine ;
}
ritorno 0 ;
}
Definiamo il file di intestazione nel codice includendo 'iostream' ed 'eccezione'. 'iostream' viene richiamato specificamente per il flusso di input e output, mentre la libreria 'exception' viene richiamata per gestire l'eccezione. Successivamente, creiamo la classe 'DemoException' che deriva dalla classe 'eccezione' di C++. Qui impostiamo la funzione virtuale what() utilizzata per fornire const char* che visualizza i risultati di un messaggio di errore collegato all'eccezione.
Quindi, invochiamo una funzione main() in cui creiamo l'oggetto “dEx” della classe “DemoException”. Successivamente, abbiamo una definizione di blocco 'try' che genera un'eccezione se incontrata. Qui lanciamo l'oggetto “dEx”.
Successivamente, impostiamo il blocco “catch” per catturare l’eccezione e gestirla. Passiamo il riferimento dell'eccezione della classe come parametro per catturare l'eccezione che ne deriva. All'interno del blocco 'catch', chiamiamo la funzione what() su 'eccetto' per ottenere il messaggio di eccezione sulla console.
Dopo aver eseguito il programma specificato, il messaggio di eccezione personalizzato viene catturato e lanciato sulla console:
Esempio 2: programma per creare un'eccezione personalizzata utilizzando due classi
Il programma enfatizza la gestione di più eccezioni che possono essere gestite in modo indipendente definendo più classi.
#include
utilizzando spazio dei nomi standard ;
classe valutazione1 { } ;
classe valutazione2 { } ;
int principale ( ) {
Tentativo {
gettare valutazione1 ( ) ;
}
presa ( valutazione1 e ) {
cout << 'Eccezione Valutazione1 rilevata!' << fine ;
}
Tentativo {
gettare valutazione2 ( ) ;
}
presa ( valutazione2 e ) {
cout << 'Eccezione valutazione 2 rilevata!' << fine ;
}
ritorno 0 ;
}
Nel codice fornito abbiamo la definizione di due classi, “Evaluation1” e “Evaluation2”, che ora sono vuote. Successivamente, eseguiamo la funzione main() del programma. Qui impostiamo il blocco try{} in cui la parola chiave 'throw' viene utilizzata per lanciare l'istanza della classe 'Evaluation1()'. Ciò rappresenta che l'eccezione 'Evaluation1' viene lanciata se si verifica un'eccezione nel programma all'interno di questo blocco 'try'. Successivamente, abbiamo un blocco catch{} in cui viene catturata l'eccezione e viene visualizzato il messaggio dell'eccezione.
Allo stesso modo, abbiamo una definizione di un altro blocco try{} per la classe “Evaluation2”. All'interno del blocco try{}, lanciamo l'istanza della classe “Evaluation2”. Ciò genera l'eccezione 'Evaluation2' se si verifica un errore qui. Quindi, chiamiamo il blocco catch{} per visualizzare il messaggio di eccezione utilizzando il comando 'cout' se l'eccezione viene catturata all'interno di questo blocco.
Nella console vengono lanciate le due eccezioni dei diversi blocchi “try-catch” che vengono gestiti dalle due diverse classi.
Esempio 3: programma per creare un'eccezione personalizzata con il costruttore
Il programma utilizza il costruttore per gestire l'eccezione. Anche se non possiamo ottenere i valori dal costruttore, possiamo farlo utilizzando il blocco “try-catch”.
#includeutilizzando spazio dei nomi standard ;
classe Test {
int val ;
pubblico :
Test ( int N )
{
Tentativo {
Se ( N == 0 )
val = N ;
Schermo ( ) ;
}
presa ( cost car * esp ) {
cout << 'Eccezione trovata \N ' ;
cout << esp << fine ;
}
}
vuoto Schermo ( )
{
cout << 'Valore = ' << val << fine ;
}
} ;
int principale ( )
{
Test ( 0 ) ;
cout << 'Creazione di nuovo dell'istanza \N ' ;
Test ( 1 ) ;
}
Nel codice fornito, stabiliamo la classe “Test” in cui la variabile è dichiarata come “val” di tipo intero. Quindi, abbiamo una definizione della funzione di costruzione “Test()” che viene passata con la variabile “n”. Successivamente impostiamo il blocco “try-catch” all'interno della funzione di costruzione “Test()”. Il blocco try viene chiamato con l'istruzione if(). Se il valore di 'n' è uguale a zero, il blocco 'catch' catturerà l'eccezione e il messaggio di eccezione verrà lanciato al prompt. Il valore di 'n' viene memorizzato nella variabile 'val' mentre la inizializziamo.
Successivamente, chiamiamo la funzione display() per mostrare il valore memorizzato nella variabile 'val'. Successivamente, abbiamo la definizione del blocco “catch” in cui viene gestita l'eccezione lanciata dal blocco “try”. Infine, invochiamo la funzione main(). All'interno del quale chiamiamo il costruttore “Test()”. Il costruttore viene attivato quando l'oggetto della classe “Test()” viene creato e specificato con il valore “0” su cui viene lanciata l'eccezione.
Successivamente, chiamiamo nuovamente la classe 'Test()' per creare un'istanza che viene passata con il valore 1. In questo caso, il costruttore non genererà alcuna eccezione poiché il valore non è uguale a 0. La funzione display() lo farà eseguire e stampare il valore di 'val'.
L'eccezione personalizzata viene generata sulla console chiamando il costruttore. Inoltre, quando la condizione è soddisfatta, il costruttore viene eseguito senza alcuna eccezione.
Esempio 4: programma per creare un'eccezione personalizzata definita dall'utente
Il programma qui gestisce e rileva l'eccezione definita dall'utente quando richiesto nel prompt.
#include#include
utilizzando spazio dei nomi standard ;
classe MyDemo : pubblico eccezione {
pubblico :
cost car * Che cosa ( ) cost gettare ( )
{
ritorno 'Eccezione! Ho provato a dividere per zero.! \N ' ;
}
} ;
int principale ( )
{
Tentativo
{
int n1, n2 ;
cout << 'Inserisci i due numeri interi: \N ' ;
mangiare >> n1 >> n2 ;
Se ( n2 == 0 )
{
La miaDemo n3 ;
gettare n3 ;
}
altro
{
cout << 'n1/n2 = ' << n1 / n2 << fine ;
}
}
presa ( eccezione & ecc )
{
cout << ecc. Che cosa ( ) ;
}
}
Nel codice fornito, definiamo innanzitutto la classe “MyDemo()” che è la classe dipendente dell'eccezione. Successivamente, impostiamo la funzione public what() con la parola chiave “virtuale”. La funzione what() viene richiamata per ottenere la causa dell'eccezione nel programma quando la funzione Throw() lancia l'eccezione. Quindi, abbiamo una funzione main() in cui sono definiti i blocchi try-catch{} per rilevare e gestire l'eccezione. All'interno del blocco try{} dichiariamo due variabili, “n1” e “n2”, i cui valori vengono presi dall'utente utilizzando il comando “cin”. Quando vengono ricevuti i valori rispetto a ciascuna variabile “n1” e “n2”, la condizione “se” controllerà se la variabile “n2” è uguale a 0 o meno. In tal caso, viene generata un'eccezione o vengono restituiti i risultati della divisione. Infine, abbiamo un blocco catch{} che prende il riferimento della classe “exception” come parametro da essa ereditato.
L'output mostra quando la condizione non è soddisfatta e il programma viene eseguito senza eccezioni:
Inoltre, definiamo il valore '0' nella variabile 'n2' per rappresentare il modo in cui l'eccezione viene lanciata e catturata nel programma.
Conclusione
In conclusione, abbiamo dimostrato l'importante concetto del C++ che costituisce un'eccezione. Un’eccezione ostacola la regolare esecuzione del programma. Per questo, abbiamo utilizzato le parole chiave “throw”, “try” e “catch” per gestire l’eccezione che si verifica nel programma. Abbiamo utilizzato queste parole chiave negli esempi precedenti per gestire l'eccezione in modo diverso.