Beispiel 1:
„Iostream“ ist die hier enthaltene Header-Datei, die wir platziert haben, damit wir die Methoden „cin“ oder „cout“ in unserem Code verwenden können, da beide Methoden darin deklariert sind. In dieser Header-Datei wird auch das „cerr“-Objekt deklariert. Dann haben wir den „std-Namespace“. Jetzt müssen wir diesen „std“ nicht mit jeder Funktion einzeln hinzufügen.
Dann wird hier „main()“ aufgerufen. Darunter nutzen wir das „cerr“-Objekt und platzieren die Fehlermeldung, die wir auf der Konsole anzeigen möchten. Wir geben „Hier ist ein Fehler aufgetreten!“ ein. Nachricht in diesem „cerr“, nachdem Sie die Einfügesymbole platziert haben. Wenn wir dieses Programm ausführen, wird die angegebene Meldung angezeigt, ohne dass „cout“ verwendet wird.
Code 1:
#includeVerwenden des Namensraums std ;
int hauptsächlich ( ) {
cerr << „Hier ist ein Fehler aufgetreten!“ << endl ;
zurückkehren 0 ;
}
Ausgabe:
Die Nachricht, die wir nach der Platzierung von „cerr <<“ eingeben, wird nun in diesem Ergebnis angezeigt, das wie folgt angezeigt wird:
Beispiel 2:
Da sowohl die Methoden „cin“ und „cout“ als auch „cerr“ in der Header-Datei „iostream“ deklariert sind, fügen wir die Header-Datei hier hinzu, damit wir sie in unserem Code verwenden können. Danach haben wir den „std-Namespace“. Darunter wird dann das „main()“ aufgerufen. Wir initialisieren den „error_str[]“ des Datentyps „string“ und weisen „error_str[]“ eine Nachricht zu. Dann verwenden wir das „cerr“-Objekt, in dem wir die Fehlermeldung platzieren und diesen „error_str“ übergeben. Wenn wir also dieses Programm ausführen, werden beide Nachrichten gerendert.
Code 2:
#includeVerwenden des Namensraums std ;
int hauptsächlich ( ) {
verkohlen error_str [ ] = „Wir können die Zeichenfolge hier nicht lesen!“ ;
cerr << 'Ein Fehler ist aufgetreten : ' << error_str << endl ;
}
Ausgabe:
Der Text, den wir nach der Eingabe von „cerr <<“ eingeben, ist jetzt im Ergebnis sichtbar, ebenso wie die Meldung, die wir in „error_str“ hinzugefügt haben. Das Ergebnis wird auch im Folgenden dargestellt:
Beispiel 3:
Nachdem wir die Header-Datei eingebunden und dann den Namensraum „std“ platziert haben, rufen wir die Methode „main()“ auf. Anschließend wird hier die Integer-Variable „NumOfLine“ deklariert und mit „__LINE__“ initialisiert. Dieses „__LINE__“ generiert die Fehlermeldungen. Darunter verwenden wir das „cerr“-Objekt und platzieren die Fehlermeldung, die wir dem Benutzer anzeigen möchten. Wir platzieren auch die Variable „NumOfLine“, die die Zeilennummer anzeigt, in der der Fehler im Code auftritt.
Code 3:
#includeVerwenden des Namensraums std ;
int hauptsächlich ( ) {
int NumOfLine = __LINIE__ ;
cerr << „Hier ist ein Fehler in der Zeile aufgetreten:“ << NumOfLine ;
zurückkehren 0 ;
}
Ausgabe:
Hier wird gezeigt, dass der Fehler in der Zeile „4“ auftritt, da wir „__LINE__“ in der vierten Zeile des Codes hinzugefügt haben. Diese Meldung wird hier mit Hilfe des „cerr“-Objekts in C++ angezeigt.
Beispiel 4:
Wir fügen eine weitere Header-Datei hinzu, die „fstream“. Diese „fstream“-Headerdatei wird in C++ zum Lesen, Schreiben oder Erstellen einer Datei verwendet, da sie eine Kombination aus „ofstream“ und „ifstream“ ist. Nachdem wir nun „std namespace“ hinzugefügt und „main()“ aufgerufen haben, verwenden wir „fstream“ mit der Variablen „new_file“.
Dann verwenden wir hier die Funktion „open()“ mit der „new_file“ und übergeben den Namen der Datei als Parameter. Der Dateiname ist „myTextFile.txt“, den wir öffnen möchten. Darunter verwenden wir „if“, um die Variable „new_file“ zu übergeben. Wenn nun die Datei hier geöffnet wird, wird die Anweisung nach „if“ gerendert. Andernfalls wird die Anweisung nach „else“ gerendert, wobei wir das „cerr“-Objekt hinzufügen, um eine Fehlermeldung anzuzeigen.
Code 4:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( ) {
fstream neue_Datei ;
neue Datei. offen ( „meineTextDatei.txt“ ) ;
Wenn ( neue Datei ) {
cout << „Die Datei wurde hier erfolgreich geöffnet!“ ;
}
anders {
cerr << „Beim Öffnen der Datei hier ist ein Fehler aufgetreten!“ ;
}
zurückkehren 0 ;
}
Ausgabe:
Wir können die zuvor bereitgestellte Datei nicht öffnen. Hier wird die Fehlermeldung angezeigt, die wir nach dem „cerr“-Objekt eingefügt haben.
Beispiel 5:
Hier wollen wir eine weitere Datei öffnen. Also fügen wir beide Header-Dateien und den „std“-Namespace hinzu. Jetzt rufen wir „main()“ auf und verwenden dann „fstream“ mit der Variablen „t_file“. Als nächstes nutzen wir in diesem Fall die Funktion „open()“ mit der „new_file“ und liefern den Dateinamen als Argument. Die Datei, die wir öffnen möchten, heißt „New.txt“. Wir verwenden die „if“-Anweisung und übergeben die Variable „t_file“. Wenn nun die Datei geöffnet wird, wird die Zeile nach „if“ gerendert. Wenn nicht, wird die Anweisung nach „else“ gerendert, in der wir das „cerr“-Objekt hinzugefügt haben, um eine Fehlermeldung anzuzeigen.
Code 5:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( ) {
fstream t_file ;
t_file. offen ( „Neu.txt“ ) ;
Wenn ( t_file ) {
cout << „Die Datei ist hier geöffnet!“ ;
}
anders {
cerr << 'Ein Fehler ist aufgetreten!' ;
}
zurückkehren 0 ;
}
Ausgabe:
Die von uns bereitgestellte Datei kann nicht geöffnet werden. Die Fehlermeldung, die wir nach dem „cerr“-Objekt hinzugefügt haben, wird also wie folgt angezeigt:
Beispiel 6:
Wir fügen hier eine „Exception“-Header-Datei hinzu, die verwendet wird, um nach Fehlern zu suchen, die in unserem Code auftreten können. Im Folgenden initialisieren wir ein Array vom Typ Integer mit dem Namen „new_array“ der Größe „6“. Dann setzen wir den „new_index“ der „int“-Variablen und weisen hier „7“ zu. Nun initialisieren wir auch die Variable „new_size“ und weisen der Variablen „new_size“ „*(&new_arr + 1) – new_arr“ zu.
Danach verwenden wir „try“, „throw“ und „catch“, um die Fehler zu überprüfen und die Fehlermeldung auszulösen. Wir verwenden das „color“-Objekt, das die Fehlermeldung anzeigt, die wir nach dem „throw“-Schlüsselwort hinzugefügt haben.
Code 6:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( ) {
int new_arr [ 6 ] = { 1 , 9 , 4 , 3 , 8 , 7 } ;
int neuer_index = 7 ;
int neue_größe = * ( & new_arr + 1 ) - new_arr ;
versuchen {
Wenn ( neuer_index < 0 || neuer_index >= neue_größe ) werfen ( „Der Index liegt nicht im Bereich. Er liegt hier außerhalb des Bereichs.“ ) ;
anders
cout << new_arr [ neuer_index ] ;
}
fangen ( const verkohlen * irren ) {
cerr << irren ;
}
zurückkehren 0 ;
}
Ausgabe:
Hier wird eine Fehlermeldung ausgegeben, die darauf hinweist, dass der „Index“ außerhalb des gültigen Bereichs liegt. Dieser Fehler wird durch die Verwendung des „cerr“-Objekts angezeigt.
Beispiel 7:
Hier prüfen wir einen Fehler, der auftreten kann, wenn wir eine Zahl durch Null dividieren. Wir erstellen eine „d()“-Funktion, in der wir zwei Variablen vom „int“-Datentyp „a1“ und „a2“ übergeben. Darunter fügen wir „if“ hinzu, in dem wir die Bedingung „a2==0“ übergeben. Wenn der Wert von „a2“ Null ist, wird die Nachricht ausgeführt, die wir nach dem „throw“ platzieren, den wir erhalten, indem wir das „cerr“-Objekt im Code platzieren.
Danach platzieren wir den „return“, der die Antwort der Division zurückgibt, wenn der Wert von „a2“ nicht Null ist. Jetzt rufen wir „main()“ auf und weisen „87“ „x“ zu, nachdem wir es als „int“-Variable initialisiert haben. Danach initialisieren wir auch die Variablen „b“ und „d_res“ mit „0“. Hier platzieren wir „try“ und „catch“, die den Fehler abfangen, und „cerr“ gibt die Fehlermeldung aus, die wir nach dem Schlüsselwort „throw“ hinzugefügt haben.
Code 7:
#includeVerwenden des Namensraums std ;
int meine_abteilung ( int a1 , int a2 ) {
Wenn ( a2 == 0 ) {
werfen „Eine Division durch Null ist nicht möglich!“ ;
}
zurückkehren ( a1 / a2 ) ;
}
int hauptsächlich ( ) {
int X = 87 ;
int Und = 0 ;
int d_nichts = 0 ;
versuchen {
d_nichts = meine_abteilung ( X , Und ) ;
cout << d_nichts << endl ;
} fangen ( const verkohlen * Nachricht ) {
cerr << Nachricht << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Hier erscheint die Fehlermeldung, dass wir die Zahl durch „0“ dividieren wollen, was unmöglich ist.
Abschluss
Das „cerr“-Objekt wird hier im Detail untersucht. Wir haben definiert, wie das „cerr“-Objekt bei der Anzeige der Fehlermeldung in der C++-Programmierung hilft. Wir haben mehrere Beispiele untersucht, in denen wir viele Bedingungen platziert haben, bei denen der Fehler auftritt. Wir haben auch das „cerr“-Objekt verwendet, nachdem wir die Try-Catch-Methode und im Dateiöffnungscode platziert hatten. Wir haben den Code sowie das Ergebnis gezeigt, bei dem „cerr“ eine Fehlermeldung anzeigt.