Maîtriser les flux C++ : cout, cin, cerr, clog – Guide pratique

Que sont les flux en C++ ?

C++ abstrait l'entrée et la sortie à travers une famille de classes de flux qui transfèrent les données comme des séquences d'octets. Ces flux sont l'épine dorsale de chaque opération d'E/S dans le langage.

Les flux se divisent en deux catégories :

Types de flux

• Flux d'entrée – Reçoivent des données depuis des périphériques comme claviers ou fichiers et les placent en mémoire.
• Flux de sortie – Envoient des données depuis la mémoire vers des périphériques comme écrans ou fichiers.

Ce tutoriel couvrira :

• Fondamentaux des flux
• Comment les flux fonctionnent sous le capot
• Classes de flux clés et leurs fonctions
• Fichiers d'en-tête C++ pour les E/S
• Utilisation de std::cout, std::cin, std::cerr et std::clog
• Gestion d'erreurs avec les objets de flux

Comment fonctionnent les flux

Le flux typique d'une opération de flux C++ est :

1. Instancier un objet de flux du type approprié.
2. Associer le flux à un périphérique ou fichier en utilisant les pointeurs get/put.
3. Effectuer les E/S via les opérateurs d'extraction (>>) ou d'insertion (<<).

Vue d'ensemble des fonctions de flux

L'en-tête streambuf fournit plusieurs classes qui gèrent les tampons de fichiers :

Classe	Description
filebuf	Gère les tampons de fichiers pour lecture/écriture. Fournit open() et close().
fstreambase	Base pour ifstream, fstream, ofstream – opérations communes de flux de fichiers.
ifstream	Flux de fichier d'entrée pour lire des données.
ofstream	Flux de fichier de sortie pour écrire des données.
fstream	Flux combiné entrée/sortie.

Fichiers d'en-tête C++ pour les E/S

• iostream – Fournit cin, cout, cerr et clog.
• iomanip – Offre des manipulateurs comme setw et setprecision.
• fstream – Gère les flux basés sur fichiers.

Tous ces objets sont définis dans iostream ; omettre l'en-tête déclenche une erreur de compilation.

std::cout

L'objet cout écrit sur le flux de sortie standard, généralement la console. Il est utilisé avec l'opérateur d'insertion (<<).

Exemple

#include <iostream>
using namespace std;
int main() {
    char welcome[] = "Welcome to Guru99";
    cout << welcome << endl;
    return 0;
}

Sortie :

Parcours du code :

1. Inclure iostream pour accéder à cout.
2. Utiliser l'espace de noms std pour éviter les préfixes.
3. Définir un tableau de caractères contenant le message.
4. Afficher le message avec endl pour insérer une nouvelle ligne.
5. Retourner 0 pour indiquer le succès.

std::cin

L'objet cin lit depuis le flux d'entrée standard, généralement le clavier. Il s'associe à l'opérateur d'extraction (>>).

Exemple

#include <iostream>
using namespace std;
int main() {
    int number;
    cout << "Enter a number:";
    cin >> number;
    cout << "\nYou entered: " << number;
    return 0;
}

Sortie :

Explication du code :

1. Inclure iostream pour cin et cout.
2. Utiliser l'espace de noms std.
3. Déclarer une variable entière.
4. Inviter l'utilisateur.
5. Lire l'entrée avec >>.
6. Réafficher la valeur entrée.
7. Retourner 0 en cas de succès.

std::cerr

Le flux cerr affiche les messages d'erreur immédiatement car il n'est pas tamponné. Utilisez-le pour les erreurs critiques qui doivent être affichées à l'instant.

Exemple

#include <iostream>
using namespace std;
int main() {
    cerr << "An Error occurred!";
    return 0;
}

Sortie :

Explication :

1. Inclure iostream pour cerr.
2. Utiliser l'espace de noms std.
3. Afficher un message d'erreur immédiatement.
4. Retourner 0.

std::clog

Contrairement à cerr, clog est tamponné, stockant les messages jusqu'à ce que le tampon soit vidé. Il est utile pour la journalisation qui peut être différée.

Exemple

#include <iostream>
using namespace std;
int main() {
    clog << "An Error occurred!";
    return 0;
}

Sortie :

Explication :

1. Inclure iostream pour clog.
2. Utiliser l'espace de noms std.
3. Écrire un message d'erreur tamponné.
4. Retourner 0.

Gestion d'erreurs avec les objets de flux

Les flux peuvent être évalués dans un contexte booléen pour vérifier leur validité. De plus, les fonctions membres fournissent des vérifications d'état granulaires :

• good() – vrai si aucune erreur ne s'est produite.
• bad() – vrai si une erreur fatale est définie.
• fail() – vrai après une opération infructueuse.
• eof() – vrai quand la fin du flux est atteinte.

Exemple – vérification d'ouverture de fichier :

ifstream file("myfile.txt");
if (!file) {
    cout << "File NOT opened!" << endl;
}

Exemple – validation de saisie utilisateur :

int p;
if (cin >> p) {
    cout << "Enter valid number" << endl;
}

Résumé

• En C++, les E/S sont effectuées via des flux qui transfèrent des séquences d'octets.
• Les flux d'entrée déplacent les données d'un périphérique vers la mémoire ; les flux de sortie déplacent les données de la mémoire vers un périphérique.
• cin (istream) lit l'entrée clavier.
• cout (ostream) écrit sur la console.
• cerr (ostream) affiche les messages d'erreur immédiats.
• clog (ostream) tamponne la sortie d'erreur pour un vidage ultérieur.
• Les flux tamponnés peuvent être vérifiés avec good(), bad(), fail() et eof().