Esempio 1:
Qui è incluso “iostream”, il file header in cui vengono dichiarate diverse funzioni. Usiamo queste funzioni dichiarate in questo file di intestazione nel nostro codice, quindi includiamo questo file di intestazione. Successivamente, abbiamo lo 'std' che viene inserito qui poiché in esso sono definite anche funzioni come 'cin' e 'cout'. Non abbiamo bisogno di digitare 'std' con tutte queste funzioni se aggiungiamo il 'namespace std' all'inizio del nostro codice. Successivamente viene richiamata la funzione “main()”, chiamata anche codice driver del programma C++.
Quindi, qui utilizziamo la parola chiave 'try' in cui inizializziamo 'my_num1' con il valore '35'. Qui è la variabile del tipo di dati 'int'. Ora inseriamo questa variabile all'interno di 'if' e inseriamo una condizione che dice che 'my_num1' deve essere maggiore o uguale a '98'. Se la condizione data è soddisfatta, va avanti all'interno di 'if' ed esegue l'istruzione qui scritta. Utilizziamo il “cout” e inseriamo un messaggio da visualizzare quando la condizione è soddisfatta.
Successivamente utilizziamo la parola chiave “throw” dopo aver inserito “else”. In questa parola chiave 'throw', passiamo 'my_num1' come parametro. Aggiungiamo la parte 'cattura' sotto questa. Inseriamo 'my_num2' come parametro di 'catch()' e quindi utilizziamo nuovamente 'cout' all'interno di questa parte 'catch'. Questa parte viene eseguita solo quando si verifica un'eccezione nella parte 'prova'.
Codice 1:
#include
utilizzando spazio dei nomi standard ;
int principale ( ) {
Tentativo {
int mio_num1 = 35 ;
Se ( mio_num1 >= 98 ) {
cout << 'L'accesso è concesso qui.' ;
} altro {
gettare ( mio_numero1 ) ;
}
}
presa ( int mio_numero2 ) {
cout << 'L'accesso è negato qui.' << fine ;
cout << 'Il numero è: ' << mio_numero2 ;
}
ritorno 0 ;
}
Produzione:
Il numero che abbiamo inserito è “35” che è inferiore a “98”. Pertanto, l'eccezione si verifica lì e viene visualizzata la parte 'catch()'. L'accesso alla parte “prova” è negato.
Esempio 2:
Inseriamo qui il file di intestazione 'iostream' e il 'namespace std'. Successivamente, creiamo una funzione “division()” in cui inseriamo due parametri che sono il “numeratore” e il “denominatore” del tipo di dati “int”. Impostiamo il tipo di dati di questa funzione di “divisione” su “raddoppiare”.
Sotto questo, aggiungiamo 'if()' in cui aggiungiamo la condizione che il denominatore sia uguale a zero. Successivamente, utilizziamo la parola chiave 'throw' e digitiamo lì un messaggio. Questo messaggio viene visualizzato ogni volta che si verifica l'eccezione in questo codice in base alla condizione. Al di sotto di questo, utilizziamo la parola chiave “return” in cui inseriamo “numeratore/denominatore”. Quindi, restituisce il risultato della divisione. Ora viene chiamata la funzione “main()”.
Successivamente, “num1” e “num2” vengono inizializzati come variabili “int” e assegnano loro rispettivamente “89” e “0”. Quindi, inizializziamo il “risultato” del tipo di dati “double”. Qui utilizziamo la parola chiave “provare”. In questa parte, aggiungiamo questa variabile “risultato” e assegniamo la funzione “divisione()” a questa variabile. Passiamo due parametri a questa funzione: “num1” e “num2”. Sotto questo, mostriamo il “risultato” che otteniamo dopo aver applicato la funzione “divisione()”. Successivamente, utilizziamo anche il “catch” e posizioniamo “const char* msg” per visualizzare il messaggio che abbiamo aggiunto in precedenza.
Codice 2:
#includeutilizzando spazio dei nomi standard ;
Doppio divisione ( int numeratore, int denominatore ) {
Se ( denominatore == 0 ) {
gettare 'Qui la divisione per zero non è possibile!' ;
}
ritorno ( numeratore / denominatore ) ;
}
int principale ( ) {
int numero1 = 89 ;
int numero2 = 0 ;
Doppio risultato = 0 ;
Tentativo {
risultato = divisione ( num1, num2 ) ;
cout << risultato << fine ;
} presa ( cost car * msg ) {
cerr << msg << fine ;
}
ritorno 0 ;
}
Produzione:
Il numero che abbiamo precedentemente inserito come denominatore è “0”. Pertanto, l'eccezione si verifica nel codice e visualizza il messaggio specificato.
Esempio 3:
Qui viene creata la funzione “moltiplicazione()”, nella quale inseriamo il “valore” e il “moltiplicatore” come parametri del tipo di dati “int”. Quindi, utilizziamo il 'se' in cui aggiungiamo una condizione moltiplicativa pari a zero. Quindi, 'lanciare' viene posizionato dove aggiungiamo un'istruzione. Poi abbiamo il “return” dove inseriamo le variabili “valore * moltiplicatore” che abbiamo dichiarato in precedenza. Quindi, restituisce qui il risultato della moltiplicazione.
Successivamente, chiamiamo 'main()' dove dichiariamo 'int value1' e 'int value2' con i valori '34' e '0', rispettivamente. Anche 'int m_res' viene dichiarato e quindi chiamato la funzione 'moltiplicazione()'. Dopo aver eseguito questa funzione, il risultato viene ora salvato nella variabile “m_res” e quindi visualizzato. Successivamente utilizziamo la funzione “catch” ed inseriamo il “const char* msg” per visualizzare il messaggio che abbiamo precedentemente aggiunto nella parte “throw”.
Codice 3:
#includeutilizzando spazio dei nomi standard ;
Doppio moltiplicazione ( int valore , int moltiplicatore ) {
Se ( moltiplicatore == 0 ) {
gettare 'Non moltiplichiamo il valore per zero!' ;
}
ritorno ( valore * moltiplicatore ) ;
}
int principale ( ) {
int valore1 = 3.4 ;
int valore2 = 0 ;
int m_res ;
Tentativo {
m_res = moltiplicazione ( valore1, valore2 ) ;
cout << m_res << fine ;
} presa ( cost car * msg ) {
cerr << msg << fine ;
}
ritorno 0 ;
}
Produzione :
Poiché il valore che abbiamo inserito in precedenza ha “0” come moltiplicatore, il codice ha un'eccezione che fa sì che l'avviso venga visualizzato qui.
Esempio 4:
Qui creiamo la funzione 'multiply()' e passiamo 'number1' e 'number2' come parametri del tipo di dati 'int'. Successivamente, utilizziamo l'operatore 'se' per aggiungere una condizione che è un moltiplicatore inferiore o uguale a zero. Successivamente, viene aggiunta la frase dove dovrebbe essere 'lanciare'. Il risultato della moltiplicazione viene poi restituito nella sezione “return” dove inseriamo la variabile “number1 * number2” che abbiamo precedentemente dichiarato.
Successivamente invochiamo la funzione “main()” e assegniamo i valori “34” e “12” rispettivamente a “int newNumber1” e “int newNumber2”. Qui la funzione “multiply()” viene richiamata dopo la dichiarazione di “int mResult”. Ora, il risultato di questa funzione è memorizzato nella variabile 'mResult' e viene visualizzato di seguito. Utilizziamo quindi la funzione “catch” e aggiungiamo “const char* msg” per visualizzare il messaggio che abbiamo scritto nella sezione “throw”.
Codice 4:
#includeutilizzando spazio dei nomi standard ;
Doppio moltiplicare ( int numero 1 , int numero 2 ) {
Se ( numero 2 <= 0 ) {
gettare 'Non moltiplichiamo il valore per zero o valore negativo!' ;
}
ritorno ( numero 1 * numero 2 ) ;
}
int principale ( ) {
int nuovoNum1 = 3.4 ;
int nuovoNum2 = 12 ;
int mRisultato ;
Tentativo {
mRisultato = moltiplicare ( nuovoNum1, nuovoNum2 ) ;
cout << 'Il risultato della moltiplicazione è' << mRisultato << fine ;
}
presa ( cost car * msg ) {
cerr << msg << fine ;
}
ritorno 0 ;
}
Produzione:
Il valore che aggiungiamo è “12” sul quale aggiungiamo la condizione. Pertanto, la funzione 'moltiplica()' viene eseguita poiché la condizione non è vera. Viene visualizzato il risultato della moltiplicazione. La parte 'prova' viene eseguita qui.
Conclusione
Il concetto “try-catch” e i codici presenti in questa guida sono studiati in dettaglio. Abbiamo esplorato a fondo questo concetto di 'prova-cattura' e abbiamo mostrato come funziona nella programmazione C++. Abbiamo definito che il termine “throw” crea un'eccezione quando viene rilevato un errore che ci consente di scrivere il nostro codice univoco. Usando l'espressione 'catch', possiamo specificare un blocco di codice da eseguire se appare un'eccezione nella parte 'try'.