C++ Entrée/sortie de base : exemple Cout, Cin, Cerr

⚡ Résumé intelligent

C++ Les opérations d'entrée et de sortie s'appuient sur des objets de flux qui déplacent les données sous forme de séquences d'octets entre les programmes et les périphériques, avec cin lisant l'entrée clavier et cout, cerr et clog écrivant la sortie à l'écran.

  • (I.e. Ruisseaux: Les tâches d'entrée et de sortie circulent sous forme de séquences d'octets appelées flux, déplaçant les données entre la mémoire principale et les périphériques.
  • (I.e. Fichiers d'en-tête : Les bibliothèques iostream, iomanip et fstream définissent les objets et les manipulateurs utilisés pour les entrées et sorties de base.
  • 🇧🇷 cout et cin : L'objet cout affiche des valeurs avec l'opérateur d'insertion, tandis que cin lit des valeurs avec l'opérateur ex.tracopérateur de tion.
  • ⚠️ cerr et sabot : Les deux systèmes signalent des erreurs, mais cerr ne met pas les messages en mémoire tampon pour un affichage immédiat, tandis que clog les met d'abord en mémoire tampon.
  • La gestion des erreurs: Les contrôles « bon », « mauvais », « échec » et « fin de fichier » lisent l'état du flux, ce qui permet de détecter les opérations ayant échoué en toute sécurité.
  • 🤖 Aide à l'IA : Les assistants de codage IA tels que GitHub Copilot génèrent le code standard cin et cout à partir d'un court commentaire ou d'un nom de fonction.

C++ Entrée/Sortie de base

Dans quoi se trouvent les flux C++?

C++ fournit aux utilisateurs un certain nombre de bibliothèques qu'ils peuvent utiliser pour effectuer des tâches d'entrée/sortie. Ces tâches sont effectuées sous la forme de séquences d'octets, communément appelées flux.

Les flux sont divisés en deux :

Types de flux

  • Flux d'entrée: Il s'agit d'un type de flux dans lequel les octets circulent d'un périphérique tel qu'un clavier vers la mémoire principale.
  • Flux de sortie : Il s'agit d'un type de flux dans lequel les octets circulent dans la direction opposée, c'est-à-dire de la mémoire principale puis vers le périphérique tel que l'écran d'affichage.

Comment fonctionnent les flux ?

C++ les flux fonctionnent comme suit :

  1. Tout d’abord, un flux est initialisé avec le bon type.
  2. Ensuite, vous devez indiquer où les opérations d'E/S auront lieu à l'aide de pointeurs get/put.
  3. Après avoir atteint le bon emplacement dans un flux, vous pouvez effectuer des tâches d'entrée et de sortie à l'aide des opérateurs >> et <<, respectivement.

Tableau des fonctions

Voici les fonctions fournies dans le fichier d'en-tête stream.h :

ClasseLes fonctions
FichierbufIl définit les tampons de fichiers en lecture/écriture. Il contient les fonctions close() et open()
fstreambaseC'est la classe de base des classes ifstream, fstream et ofstream. Ses opérations sont communes aux flux de fichiers.
ifstreamIl s'agit d'une classe de flux de fichiers d'entrée permettant de fournir des opérations d'entrée.
hors fluxIl s'agit d'une classe de flux de fichiers de sortie permettant de fournir des opérations de sortie.
fstreamC'est une classe de flux d'entrée/sortie. Il prend en charge les opérations d'entrée/sortie simultanées.

C++ Fichiers d'en-tête pour l'entrée/sortie

C++ fournit trois bibliothèques dotées de fonctions permettant d'effectuer des tâches d'entrée/sortie de base. Ils comprennent :

  • Iostream : C'est un acronyme pour flux d'entrée/sortie standard. Ce fichier d'en-tête est livré avec des définitions d'objets comme cin/cout/cerr.
  • Iomanip : C'est un acronyme pour manipulateurs d'entrée/sortie. La bibliothèque est livrée avec des fonctions qui peuvent être utilisées pour la manipulation de flux. Il contient des définitions d'objets comme setw, setprecision et autres.
  • Fstream : Il s'agit d'un fichier d'en-tête pour décrire le flux de fichiers. Il gère les données lues à partir d'un fichier en entrée ou écrites dans un fichier, en sortie.

Les mots-clés cin et cout sont très populaires dans C++. Ils sont utilisés respectivement pour prendre des entrées et imprimer des sorties. Pour les utiliser, vous devez inclure le fichier d'en-tête iostream dans votre programme. La raison est qu'ils sont définis dans ce fichier d'en-tête. Le fait de ne pas inclure le fichier d’en-tête iostream générera une erreur. Cela résulte d'un échec du C++ compilateur pour comprendre la signification des mots-clés.

Les principaux objets définis dans le fichier d'en-tête iostream sont cin, cout, cerr et clog. Discutons-en.

std :: cout

L'objet cout est une instance de la classe iostream. Il est utilisé pour produire une sortie sur un périphérique de sortie standard, qui est normalement l'écran. Il est utilisé avec l'opérateur d'insertion de flux (<<).

Exemple

#include <iostream>
using namespace std;
int main() {

	char welcome[] = "Welcome to Guru99";

	cout << welcome << endl;

	return 0;
}

Sortie :

std :: cout

Voici une capture d'écran du code :

std :: cout

Code Explication:

  1. Incluez le fichier d'en-tête iostream dans lequel l'objet cout est défini.
  2. Incluez l'espace de noms std afin que nous n'ayons pas à l'appeler lors de l'utilisation de ses classes.
  3. Appelez la fonction main(). Le code du programme doit être ajouté dans son corps. L'accolade ouvrante { marque le début de son corps.
  4. Créez une variable de type caractère nommée welcome pour stocker la chaîne « Bienvenue à » Guru99.
  5. Imprime la valeur de la chaîne bienvenue sur la console. La fin est un C++ mot-clé signifiant ligne de fin. Il déplace le curseur pour commencer à imprimer le texte sur la ligne suivante.
  6. Le programme doit renvoyer une valeur en cas d'exécution réussie.
  7. Fin du corps de la fonction main().

std ::cin

L'objet cin est une instance de la classe istream. Il lit les données saisies depuis le périphérique d'entrée, le clavier. Il est généralement utilisé conjointement avec l'objet ex.tracL'opérateur de tion (>>). L'extracL'objet tion est responsable de extracting les données saisies au clavier à partir de l'objet cin.

Exemple

L'exemple suivant montre comment utiliser le mot-clé cin dans C++:

#include <iostream>
using namespace std;
int main()
{
	int number;

	cout << "Enter a number:";
	cin >> number;
	cout << "\nYou entered: " << number;

	return 0;
}

Sortie :

std ::cin

Voici une capture d'écran du code :

std ::cin

Code Explication:

  1. Incluez le fichier d'en-tête iostream dans notre programme. L'objet cin est défini dans ce fichier d'en-tête.
  2. Incluez l'espace de noms std pour utiliser ses classes. Vous n'aurez pas besoin d'appeler std lors de l'utilisation de ses classes.
  3. Appelez la fonction main(). Le code du programme doit être ajouté dans son corps.
  4. Le début du corps du programme.
  5. Déclarer un variable entière numéro nommé.
  6. Imprimez un message à l'écran invitant l'utilisateur à saisir un numéro.
  7. Lire la valeur saisie par l'utilisateur sur la console à partir du clavier.
  8. Imprimez la valeur lue ci-dessus sur la console à côté d'un autre texte.
  9. Le programme doit renvoyer une valeur s'il s'exécute avec succès.
  10. Fin du corps de la fonction principale.

std ::cerr

L'objet cerr forme le flux d'erreurs standard pour générer des erreurs dans C++. Cerr est une instance de la classe ostream. L'objet cerr n'est pas mis en mémoire tampon. Cela signifie qu'il est utilisé lorsqu'un message d'erreur doit être affiché immédiatement.

Comme il n'est pas mis en mémoire tampon, il ne stocke pas de message d'erreur pour un affichage ultérieur. Il est utilisé avec l'opérateur d'insertion de flux (<<).

Exemple

#include <iostream>
using namespace std;
int main() {

	cerr << "An Error occurred!";

	return 0;
}

Sortie :

std ::cerr

Voici une capture d'écran du code :

std ::cerr

Code Explication:

  1. Inclut le fichier d'en-tête iostream où l'objet cerr a été défini.
  2. Incluez l'espace de noms std afin que nous n'ayons pas à l'appeler lors de l'utilisation de ses classes.
  3. Appelez la fonction main(). La logique du programme doit être ajoutée dans son corps. L'accolade ouvrante marque le début du corps de la fonction.
  4. Utilisez l'objet cerr pour imprimer une erreur sur la console.
  5. Le programme doit renvoyer une valeur en cas d'exécution réussie.
  6. Fin du corps de la fonction principale.

std :: obstruer

L'objet clog est une instance de la classe ostream. Il est utilisé pour afficher les erreurs sur l'écran standard, le moniteur. C'est similaire à l'objet cerr, mais il est mis en mémoire tampon. Puisqu'il est mis en mémoire tampon, il stocke le message d'erreur dans le tampon jusqu'à ce que le tampon soit rempli/vidé. Il est utilisé avec l'opérateur d'insertion de flux (<<).

Exemple

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

Sortie :

std :: obstruer

Voici une capture d'écran du code :

std :: obstruer

Code Explication:

  1. Y compris le fichier d'en-tête iostream dans lequel l'objet clog est défini.
  2. Y compris l'espace de noms std afin que nous puissions utiliser ses classes sans l'appeler.
  3. Appel de la fonction main(). La logique du programme doit être ajoutée dans son corps. Le { marque le début du corps de la fonction.
  4. Utilisez l'objet sabot pour imprimer une erreur sur la sortie standard, le moniteur.
  5. Le programme doit renvoyer une valeur une fois terminé.
  6. La fin du corps de la fonction main().

Gestion des erreurs avec les flux IO

Ces mêmes objets de flux indiquent également si une opération a réussi, ce que révèlent les vérifications d'état du flux.

Pour vérifier si un flux est valide ou non, vous pouvez l'utiliser comme booléen.

Voici un exemple:

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

Pour obtenir plus de détails sur l'état du flux, vous pouvez utiliser ces fonctions :

  • good()- retournera true si tout va bien.
  • mauvais()- retournera vrai si une erreur fatale se produit.
  • fail()- renverra true après une opération de flux infructueuse.
  • eof()- retournera true s'il atteint la fin d'un fichier.

Pour savoir si une opération de lecture/écriture particulière a échoué, testez le résultat de la lecture.

Par exemple, pour vérifier si l'utilisateur a saisi un entier valide, procédez comme suit :

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

FAQ

L'objet `cout` est sûr en termes de types et utilise l'opérateur d'insertion, ce qui lui permet de détecter automatiquement le type de chaque valeur. La fonction `printf` du C, quant à elle, repose sur des spécificateurs de format tels que `%d`, qui doivent correspondre manuellement aux arguments.

L' extracL'opérateur de saut de ligne s'arrête au premier espace ; par conséquent, cin ne lit qu'un seul mot. Pour capturer une ligne entière avec des espaces, appelez getline(cin, variable), qui lit jusqu'au caractère de nouvelle ligne.

Les deux instructions permettent de commencer une nouvelle ligne, mais `endl` vide également le tampon de sortie à chaque fois, ce qui peut ralentir les boucles actives. Il est préférable d'utiliser un simple saut de ligne et de réserver `endl` aux cas où le vidage du tampon doit être immédiat.

Les objets cin, cout, cerr et clog se trouvent dans l'espace de noms std. L'utilisation de l'espace de noms std permet d'écrire cout plutôt que std::cout. Dans les grands projets, le préfixe std est souvent conservé explicitement afin d'éviter les conflits.

Incluez l'en-tête iomanip et utilisez les manipulateurs avec cout. Le manipulateur setw réserve une largeur de champ, et setprecision définit le nombre de chiffres affichés, en formatant les nombres et les colonnes sans modifier les valeurs stockées.

Oui. Comme `cout` et `cerr` sont des flux distincts, un shell peut rediriger la sortie normale vers un fichier tandis que les erreurs s'affichent à l'écran. En programmation, `rdbuf` permet de diriger un flux vers un autre tampon.

Oui. Les assistants de programmation IA lisent un commentaire ou un nom de fonction et produisent des instructions cin et cout, ainsi que l'inclusion iostream et une invite formatée. RevIl est judicieux de consulter la logique du flux généré pour les cas limites.

Oui. Copilote GitHub Il effectue la mise en forme des commandes cout, les boucles de validation cin et les vérifications d'erreurs cerr au fur et à mesure de votre saisie. Nous sommes en 2026. C++ L'intelligence du code ajoute une prise en compte des symboles sémantiques, ce qui permet de maintenir la cohérence des suggestions multi-fichiers.

Résumez cet article avec :