Esempio 1:
'iostream' è il file di intestazione incluso qui che abbiamo inserito in modo da poter utilizzare i metodi 'cin' o 'cout' nel nostro codice poiché entrambi i metodi sono dichiarati al suo interno. Anche l'oggetto “cerr” è dichiarato in questo file di intestazione. Quindi, abbiamo lo “spazio dei nomi std”. Ora, non abbiamo bisogno di aggiungere questo “std” con ciascuna funzione in modo indipendente.
Quindi, qui viene richiamato 'main()'. Sotto questo utilizziamo l'oggetto “cerr” e inseriamo il messaggio di errore che vogliamo visualizzare sulla console. Digitiamo il messaggio 'Si è verificato un errore qui!' messaggio in questo “cerr” dopo aver posizionato i simboli di inserimento. Quando eseguiamo questo programma, il messaggio indicato viene visualizzato senza utilizzare il 'cout'.
Codice 1:
#includeutilizzando lo spazio dei nomi std ;
int principale ( ) {
cerr << 'Si è verificato un errore qui!' << fine ;
ritorno 0 ;
}
Produzione:
Il messaggio che digitiamo dopo aver inserito 'cerr <<' viene ora visualizzato in questo risultato che viene visualizzato di seguito:
Esempio 2:
Poiché sia i metodi 'cin' che 'cout' nonché 'cerr' sono dichiarati all'interno del file di intestazione 'iostream', aggiungiamo qui il file di intestazione in modo da poterli utilizzare nel nostro codice. Successivamente, abbiamo lo “spazio dei nomi std”. Al di sotto di questo, viene quindi chiamato 'main()'. Inizializziamo “error_str[]” del tipo di dati “string” e assegniamo un messaggio a “error_str[]”. Quindi, utilizziamo l'oggetto “cerr” in cui inseriamo il messaggio di errore e passiamo questo “error_str”. Quindi, quando eseguiamo questo programma, esegue il rendering di entrambi i messaggi.
Codice 2:
#includeutilizzando lo spazio dei nomi std ;
int principale ( ) {
car errore_str [ ] = 'Non possiamo leggere la stringa qui!' ;
cerr << 'C'è stato un'errore : ' << errore_str << fine ;
}
Produzione:
Il testo che digitiamo dopo aver digitato “cerr <<” è ora visibile nel risultato così come il messaggio che abbiamo aggiunto in “error_str”. Il risultato è mostrato anche di seguito:
Esempio 3:
Dopo aver incluso il file di intestazione e aver posizionato lo spazio dei nomi 'std', chiamiamo il metodo 'main()'. Successivamente, la variabile intera “NumOfLine” viene dichiarata qui e inizializzata con “__LINE__”. Questo “__LINE__” genera i messaggi di errore. Sotto utilizziamo l'oggetto “cerr” e inseriamo il messaggio di errore che vogliamo mostrare all'utente. Inseriamo anche la variabile “NumOfLine” che mostra il numero di riga su cui si verifica l'errore nel codice.
Codice 3:
#includeutilizzando lo spazio dei nomi std ;
int principale ( ) {
int NumDiLine = __LINEA__ ;
cerr << 'Si è verificato un errore qui sulla riga: ' << NumDiLine ;
ritorno 0 ;
}
Produzione:
Qui mostra che l'errore si verifica sulla riga '4' poiché abbiamo aggiunto '__LINE__' sulla quarta riga del codice. Questo messaggio viene visualizzato qui con l'aiuto dell'oggetto “cerr” in C++.
Esempio 4:
Includiamo un altro file di intestazione, 'fstream'. Questo file di intestazione 'fstream' viene utilizzato in C++ per leggere, scrivere o creare un file poiché è la combinazione di 'ofstream' e 'ifstream'. Ora, dopo aver aggiunto 'std namespace' e invocato 'main()', utilizziamo 'fstream' con la variabile 'new_file'.
Quindi, qui utilizziamo la funzione 'open()' con 'new_file' e passiamo il nome del file come parametro. Il nome del file è 'myTextFile.txt' che vogliamo aprire. Al di sotto di questo, utilizziamo 'if' per passare la variabile 'new_file'. Ora, se il file si apre qui, viene resa l'istruzione dopo 'if'. Altrimenti, viene renderizzata l'istruzione dopo “else” dove aggiungiamo l'oggetto “cerr” per mostrare un messaggio di errore.
Codice 4:
#include#include
utilizzando lo spazio dei nomi std ;
int principale ( ) {
fstream nuovo_file ;
nuovo file. aprire ( 'mioFileDiTesto.txt' ) ;
Se ( nuovo file ) {
cout << 'Il file è stato aperto con successo qui!' ;
}
altro {
cerr << 'Si è verificato un errore qui durante l'apertura del file qui!' ;
}
ritorno 0 ;
}
Produzione:
Non possiamo aprire il file che abbiamo fornito in precedenza. Qui viene visualizzato il messaggio di errore che abbiamo inserito dopo l'oggetto “cerr”.
Esempio 5:
Qui, vogliamo aprire un altro file. Quindi, aggiungiamo sia i file di intestazione che lo spazio dei nomi 'std'. Ora chiamiamo 'main()' e quindi utilizziamo 'fstream' con la variabile 't_file'. Successivamente, utilizziamo la funzione 'open()' in questa istanza con 'new_file' e forniamo il nome del file come argomento. Il file che desideriamo aprire si chiama “New.txt”. Usiamo l'istruzione 'if', passando la variabile 't_file'. Ora, se il file si apre, viene renderizzata la riga che segue 'if'. In caso contrario, viene renderizzata l'istruzione che segue 'else', dove abbiamo aggiunto l'oggetto 'cerr' per visualizzare un messaggio di errore.
Codice 5:
#include#include
utilizzando lo spazio dei nomi std ;
int principale ( ) {
fstream t_file ;
t_file. aprire ( 'Nuovo.txt' ) ;
Se ( t_file ) {
cout << 'Il file è aperto qui!' ;
}
altro {
cerr << 'C'è stato un'errore!' ;
}
ritorno 0 ;
}
Produzione:
Impossibile aprire il file fornito. Pertanto, il messaggio di errore che abbiamo aggiunto dopo l'oggetto “cerr” viene visualizzato nel modo seguente:
Esempio 6:
Aggiungiamo qui un file di intestazione 'eccezione' che viene utilizzato per verificare la presenza di errori che potrebbero verificarsi nel nostro codice. Di seguito, inizializziamo un array di tipo intero denominato “new_array” della dimensione “6”. Quindi, impostiamo il 'new_index' della variabile 'int' e assegniamo qui '7'. Ora inizializziamo anche la variabile “new_size” e assegniamo “*(&new_arr + 1) – new_arr” alla variabile “new_size”.
Successivamente, utilizziamo 'try', 'throw' e 'catch' che vengono utilizzati per verificare gli errori e generare il messaggio di errore. Utilizziamo l'oggetto “color” che mostra il messaggio di errore che abbiamo aggiunto dopo la parola chiave “throw”.
Codice 6:
#include#include
utilizzando lo spazio dei nomi std ;
int principale ( ) {
int nuovo_arr [ 6 ] = { 1 , 9 , 4 , 3 , 8 , 7 } ;
int nuovo_indice = 7 ;
int nuova_dimensione = * ( & nuovo_arr + 1 ) - nuovo_arr ;
Tentativo {
Se ( nuovo_indice < 0 || nuovo_indice >= nuova_dimensione ) gettare ( 'L'indice non è nell'intervallo. Qui è fuori intervallo' ) ;
altro
cout << nuovo_arr [ nuovo_indice ] ;
}
presa ( cost car * errare ) {
cerr << errare ;
}
ritorno 0 ;
}
Produzione:
Qui, viene visualizzato un messaggio di errore che mostra che 'Indice' è fuori intervallo e otteniamo questo errore utilizzando l'oggetto 'cerr'.
Esempio 7:
Qui controlliamo un errore che può verificarsi quando dividiamo un numero per zero. Creiamo una funzione “d()” in cui passiamo due variabili di tipo dati “int” “a1” e “a2”. Sotto questo, aggiungiamo 'if' in cui passiamo la condizione 'a2==0'. Se il valore di “a2” è zero viene eseguito il messaggio che inseriamo dopo il “throw” che otteniamo inserendo nel codice l'oggetto “cerr”.
Successivamente inseriamo il “return” che restituisce la risposta della divisione se il valore di “a2” non è zero. Ora invochiamo 'main()' e assegniamo '87' a 'x' dopo averlo inizializzato come variabile 'int'. Successivamente inizializziamo anche le variabili “b” e “d_res” con “0”. Qui inseriamo 'try' e 'catch' che rilevano l'errore e 'cerr' genera il messaggio di errore che abbiamo aggiunto dopo la parola chiave 'throw'.
Codice 7:
#includeutilizzando lo spazio dei nomi std ;
int mia_divisione ( int a1 , int a2 ) {
Se ( a2 == 0 ) {
gettare 'La divisione per zero non è possibile!' ;
}
ritorno ( a1 / a2 ) ;
}
int principale ( ) {
int X = 87 ;
int E = 0 ;
int d_niente = 0 ;
Tentativo {
d_niente = mia_divisione ( X , E ) ;
cout << d_niente << fine ;
} presa ( cost car * msg ) {
cerr << msg << fine ;
}
ritorno 0 ;
}
Produzione:
Qui appare il messaggio di errore che significa che vogliamo dividere il numero per “0”, il che è impossibile.
Conclusione
L'oggetto “cerr” è studiato in dettaglio qui. Abbiamo definito il modo in cui l'oggetto 'cerr' aiuta a visualizzare il messaggio di errore nella programmazione C++. Abbiamo esplorato più esempi in cui abbiamo inserito molte condizioni in cui si verifica l'errore. Abbiamo utilizzato anche l'oggetto “cerr” dopo aver inserito il metodo try-catch e nel codice di apertura del file. Abbiamo mostrato il codice e il risultato in cui “cerr” visualizza un messaggio di errore.