Exemple 1:
Le « iostream » est le fichier d'en-tête inclus ici que nous avons placé afin que nous puissions utiliser les méthodes « cin » ou « cout » dans notre code car les deux méthodes y sont déclarées. L'objet « cerr » est également déclaré dans ce fichier d'en-tête. Ensuite, nous avons « l’espace de noms std ». Désormais, nous n'avons plus besoin d'ajouter ce « std » avec chaque fonction indépendamment.
Ensuite, « main() » est invoqué ici. En dessous, nous utilisons l'objet « cerr » et plaçons le message d'erreur que nous souhaitons afficher sur la console. Nous tapons le message « Une erreur s'est produite ici ! » message dans ce « cerr » après avoir placé les symboles d’insertion. Lorsque nous exécutons ce programme, le message donné est affiché sans utiliser le « cout ».
Codage 1 :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
cerr << « Une erreur s'est produite ici ! » << fin ;
retour 0 ;
}
Sortir:
Le message que nous tapons après avoir placé « cerr << » est maintenant affiché dans ce résultat qui s'affiche comme suit :
Exemple 2 :
Comme les méthodes « cin » et « cout » ainsi que « cerr » sont déclarées dans le fichier d'en-tête « iostream », nous ajoutons le fichier d'en-tête ici afin de pouvoir les utiliser dans notre code. Après cela, nous avons « l’espace de noms std ». En dessous, le « main() » est alors appelé. Nous initialisons le « error_str[] » du type de données « string » et attribuons un message à « error_str[] ». Ensuite, nous utilisons l'objet « cerr » où nous plaçons le message d'erreur et transmettons ce « error_str ». Ainsi, lorsque nous exécutons ce programme, il restitue les deux messages.
Code 2 :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
carboniser erreur_str [ ] = 'Nous ne pouvons pas lire la chaîne ici !' ;
cerr << 'Erreur est survenue : ' << erreur_str << fin ;
}
Sortir:
Le texte que nous tapons après avoir tapé « cerr << » est désormais visible dans le résultat ainsi que le message que nous avons ajouté dans le « error_str ». Le résultat est également illustré ci-dessous :
Exemple 3 :
Après avoir inclus le fichier d'en-tête puis placé l'espace de noms « std », nous appelons la méthode « main() ». Après cela, la variable entière « NumOfLine » est déclarée ici et initialisée avec « __LINE__ ». Ce « __LINE__ » génère les messages d'erreur. En dessous, nous utilisons l'objet « cerr » et plaçons le message d'erreur que nous souhaitons afficher à l'utilisateur. On place également la variable « NumOfLine » qui montre le numéro de ligne sur laquelle l'erreur se produit dans le code.
Code 3 :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
int NuméroDeLigne = __DOUBLER__ ;
cerr << 'Une erreur s'est produite ici sur la ligne : ' << NuméroDeLigne ;
retour 0 ;
}
Sortir:
Ici, cela montre que l'erreur se produit sur la ligne « 4 » car nous avons ajouté le « __LINE__ » sur la quatrième ligne du code. Ce message est affiché ici à l'aide de l'objet « cerr » en C++.
Exemple 4 :
Nous incluons un autre fichier d'en-tête, le « fstream ». Ce fichier d'en-tête « fstream » est utilisé en C++ pour lire, écrire ou créer un fichier car il s'agit de la combinaison du « ofstream » et du « ifstream ». Maintenant, après avoir ajouté « std namespace » et invoqué « main() », nous utilisons le « fstream » avec la variable « new_file ».
Ensuite, nous utilisons ici la fonction « open() » avec le « new_file » et passons le nom du fichier en paramètre. Le nom du fichier est « myTextFile.txt » que nous voulons ouvrir. En dessous, nous utilisons « if » pour transmettre la variable « new_file ». Désormais, si le fichier s'ouvre ici, l'instruction après « if » est rendue. Sinon, l'instruction après « else » est rendue où nous ajoutons l'objet « cerr » pour afficher un message d'erreur.
Code 4 :
#include#include
en utilisant l'espace de noms std ;
int principal ( ) {
fstream nouveau_fichier ;
nouveau fichier. ouvrir ( 'monFichierTexte.txt' ) ;
si ( nouveau fichier ) {
cout << « Le fichier est ouvert avec succès ici ! » ;
}
autre {
cerr << 'Une erreur s'est produite ici lors de l'ouverture du fichier ici !' ;
}
retour 0 ;
}
Sortir:
Nous ne pouvons pas ouvrir le fichier que nous avons fourni précédemment. Ici, il affiche le message d'erreur que nous avons inséré après l'objet « cerr ».
Exemple 5 :
Ici, nous voulons ouvrir un autre fichier. Nous ajoutons donc les deux fichiers d'en-tête et l'espace de noms « std ». Maintenant, nous appelons le « main() », puis utilisons le « fstream » avec la variable « t_file ». Ensuite, nous utilisons la fonction « open() » dans ce cas avec le « new_file » et fournissons le nom du fichier comme argument. Le fichier que nous souhaitons ouvrir s'appelle « New.txt ». Nous utilisons l'instruction « if », en passant la variable « t_file ». Désormais, si le fichier s'ouvre, la ligne qui suit « if » est rendue. Sinon, l'instruction qui suit « else », où nous avons ajouté l'objet « cerr » pour afficher un message d'erreur, est rendue.
Code 5 :
#include#include
en utilisant l'espace de noms std ;
int principal ( ) {
fstream t_file ;
t_file. ouvrir ( 'Nouveau.txt' ) ;
si ( fichier_t ) {
cout << 'Le dossier est ouvert ici !' ;
}
autre {
cerr << 'Erreur est survenue!' ;
}
retour 0 ;
}
Sortir:
Le fichier que nous avons fourni ne peut pas être ouvert. Ainsi, le message d'erreur que nous avons ajouté après l'objet « cerr » s'affiche comme suit :
Exemple 6 :
Nous ajoutons ici un fichier d'en-tête « exception » qui est utilisé pour vérifier les erreurs qui peuvent survenir dans notre code. Dans ce qui suit, nous initialisons un tableau de type entier nommé « new_array » de taille « 6 ». Ensuite, nous définissons le « new_index » de la variable « int » et attribuons « 7 » ici. Maintenant, nous initialisons également la variable « new_size » et attribuons « *(&new_arr + 1) – new_arr » à la variable « new_size ».
Après cela, nous utilisons les éléments « essayer », « lancer » et « catch » qui sont utilisés pour vérifier les erreurs et renvoyer le message d'erreur. Nous utilisons l'objet « color » qui affiche le message d'erreur que nous avons ajouté après le mot-clé « throw ».
Code 6 :
#include#inclure
en utilisant l'espace de noms std ;
int principal ( ) {
int nouveau_arr [ 6 ] = { 1 , 9 , 4 , 3 , 8 , 7 } ;
int nouveau_index = 7 ;
int nouvelle_taille = * ( & nouveau_arr + 1 ) - nouveau_arr ;
essayer {
si ( nouveau_index < 0 || nouveau_index >= nouvelle_taille ) lancer ( 'L'index n'est pas dans la plage. Il est hors plage ici' ) ;
autre
cout << nouveau_arr [ nouveau_index ] ;
}
attraper ( const carboniser * se tromper ) {
cerr << se tromper ;
}
retour 0 ;
}
Sortir:
Ici, il affiche un message d'erreur qui montre que « l'index » est hors de portée et nous obtenons cette erreur en utilisant l'objet « cerr ».
Exemple 7 :
Ici, nous vérifions une erreur qui peut survenir lorsque nous divisons un nombre par zéro. Nous créons une fonction « d() » dans laquelle nous passons deux variables de type de données « int » « a1 » et « a2 ». En dessous, on ajoute « if » dans lequel on passe la condition « a2==0 ». Si la valeur de « a2 » est zéro, le message que nous plaçons après le « lancer » est exécuté, ce que nous obtenons en plaçant l'objet « cerr » dans le code.
Après cela, on place le « retour » qui renvoie la réponse de la division si la valeur de « a2 » n’est pas nulle. Maintenant, nous invoquons le « main() » et attribuons « 87 » à « x » après l'avoir initialisé en tant que variable « int ». Après cela, nous initialisons également les variables « b » et « d_res » avec « 0 ». Ici, nous plaçons le « try » et le « catch » qui détectent l'erreur et le « cerr » renvoie le message d'erreur que nous avons ajouté après le mot-clé « throw ».
Code 7 :
#includeen utilisant l'espace de noms std ;
int ma_division ( int a1 , int a2 ) {
si ( a2 == 0 ) {
lancer 'La division par zéro n'est pas possible !' ;
}
retour ( a1 / a2 ) ;
}
int principal ( ) {
int X = 87 ;
int et = 0 ;
int d_rien = 0 ;
essayer {
d_rien = ma_division ( X , et ) ;
cout << d_rien << fin ;
} attraper ( const carboniser * message ) {
cerr << message << fin ;
}
retour 0 ;
}
Sortir:
Ici, le message d'erreur apparaît qui signifie que l'on veut diviser le nombre par « 0 » ce qui est impossible.
Conclusion
L’objet « cerr » est étudié ici en détail. Nous avons défini comment l'objet « cerr » aide à afficher le message d'erreur dans la programmation C++. Nous avons exploré plusieurs exemples dans lesquels nous avons placé de nombreuses conditions dans lesquelles l'erreur se produit. Nous avons également utilisé l'objet « cerr » après avoir placé la méthode try-catch et dans le code d'ouverture du fichier. Nous avons montré le code ainsi que le résultat dans lequel le « cerr » affiche un message d'erreur.