L’opération d’E/S C++ utilise le concept de flux. La série d'octets ou le flux de données est appelé flux. Cela accélère les performances.
Si des octets sont transférés de la mémoire principale vers un périphérique tel qu'une imprimante, un écran d'affichage, une connexion réseau, etc., cela s'appelle une opération de sortie.
Une opération d'entrée se produit lorsque des octets circulent d'un périphérique tel qu'une imprimante, un écran d'affichage ou une connexion réseau vers la mémoire principale.
En C++, fonctions prédéfinies et les déclarations sont fournies via des fichiers d'en-tête, vous permettant d'effectuer des tâches spécifiques sans avoir à écrire de nouveau code depuis le début. Quelques fichiers d'en-tête importants pour les opérations d'entrée/sortie en C++ incluent des fonctions permettant d'effectuer efficacement les tâches d'entrée et de sortie. La bibliothèque standard C++, une collection de classes et de méthodes créées dans le langage de programmation C++, contient ces fichiers d'en-tête. Discutons des principaux fichiers d'en-tête pour les opérations d'entrée/sortie :
| En tête de fichier | Fonction et description |
|---|---|
| Il est utilisé pour définir le cout, cin et cerr objets, qui correspondent respectivement au flux de sortie standard, au flux d’entrée standard et au flux d’erreur standard. | |
| Il est utilisé pour déclarer des services utiles pour effectuer des E/S formatées, telles que setprecision et setw. | |
| Il est utilisé pour déclarer des services pour le traitement de fichiers contrôlé par l'utilisateur. |
iostream : C'est l'un des fichiers d'en-tête les plus importants pour les opérations d'entrée/sortie en C++. Ça signifie 'entrée sortie' flux. Pour travailler avec diverses formes de flux d'entrée/sortie, le iostream le fichier d'en-tête inclut les classes istream (flux d'entrée) et ostream (flux de sortie) ainsi que ses classes dérivées ifstream, ofstream , et flux de chaînes . Les classes les plus généralement utilisées dans ce fichier d'en-tête sont cin (entrée standard) et cout (sortie standard) , qui vous permettent de lire les entrées de l'utilisateur et d'afficher la sortie sur la console. Par exemple:
#include using namespace std; int main() { int num; cout <> num; cout << 'You entered: ' << num << endl; return 0; } Sortir
Enter a number: 42 You entered: 42
iomanip : Ce fichier d'en-tête représente 'manipulation entrée-sortie' . Il fournit des outils pour formater saisir et sortir . Il vous permet de modifier le alignement, largeur, précision , ainsi que d'autres fonctionnalités de formatage de l'entrée et de la sortie. Setw, setprecision, fixe, gauche, droite , et d'autres fonctions régulièrement utilisées sont répertoriées ci-dessous. C’est particulièrement pratique pour présenter les données d’une certaine manière.
Exemple:
#include #include using namespace std; int main() { double pi = 3.14159; cout << fixed << setprecision(2) << 'Value of pi: ' << pi << endl; return 0; } Sortir
liste trier java
Value of pi: 3.14
flux: Le fichier d'en-tête pour les opérations d'entrée/sortie de fichier est appelé fstream . Il comprend des classes pour lire et écrire dans des fichiers ifstream (flux de fichier d'entrée) et ofstream (flux de fichier de sortie) . Le système utilise ces classes pour ouvrir des fichiers en lecture seule et en écriture seule.
Exemple:
#include #include using namespace std; int main() { ofstream outputFile('output.txt'); if (outputFile.is_open()) { outputFile << 'Hello, File I/O!'; outputFile.close(); cout << 'File is written successfully.' << endl; } else { cout << 'Failed to open the file.' << endl; } return 0; } Sortir
The file was written successfully.
Ces fichiers d'en-tête sont parmi les plus cruciaux pour les tâches d'entrée/sortie C++. Chacun a un objectif précis et offre les outils nécessaires pour gérer avec succès les tâches impliquant des entrées et des sorties, qu'elles interagissent avec le console, formatage de la sortie , ou travailler avec des fichiers.
En C++, nous utilisons fréquemment 'en utilisant l'espace de noms std;' après les fichiers d'en-tête. Le espace de noms std ; L'instruction est fréquemment utilisée en C++ pour rationaliser le code lorsque vous travaillez avec des composants de bibliothèque standard. Examinons la fonction et l'application de cette instruction plus en détail :
UN espace de noms est une technique permettant de regrouper des identifiants similaires (tels que classes, fonctions , et variables ) pour éviter les conflits de noms. La bibliothèque standard C++ fournit ses parties (telles que cin, cout, etc.) sous l'espace de noms std.
Le terme 'standard' est raccourci à 'std' , et tous les éléments de la bibliothèque standard y sont contenus. Ce faisant, les conflits de noms avec les identifiants définis dans votre code sont réduits.
Parlons maintenant de la raison pour laquelle l'utilisation de l'espace de noms std ; l'instruction est utilisée :
Sans utiliser l'espace de noms std :
#include int main() { std::cout << 'Hello, world!' << std::endl; return 0; } With using namespace std: #include using namespace std; int main() { cout << 'Hello, world!' << endl; return 0; } Comme vous pouvez le constater, en utilisant le espace de noms std ; l'instruction vous permet d'omettre le std :: préfixe lors de l’accès aux composants de bibliothèque standard. Cela rend votre code plus court et plus lisible, car vous n'avez pas besoin de le répéter norme :: avant chaque identifiant de bibliothèque standard.
Fichiers d'en-tête de bibliothèque d'E/S
Flux de sortie standard (cout) :
L'objet cout est un objet prédéfini de classe ostream. Il est connecté au périphérique de sortie standard, qui est généralement un écran d'affichage. Le cout est utilisé en combinaison avec l'opérateur d'insertion de flux (<<) to show the output on a console< p>
Voyons l'exemple simple d'un flux de sortie standard (cout) :
#include using namespace std; int main( ) { char ary[] = 'Welcome to C++ tutorial'; cout << 'Value of ary is: ' << ary << endl; } Sortir
Value of ary is: Welcome to C++ tutorial
Flux d'entrée standard (cin)
Le manger est un objet prédéfini de flux classe. Il est connecté au périphérique d’entrée standard, qui est généralement un clavier. Le cin est utilisé conjointement avec l'opérateur d'extraction de flux (>>) pour lire l'entrée d'une console.
Voyons l'exemple simple de flux d'entrée standard (cin) :
#include using namespace std; int main( ) { int age; cout <> age; cout << 'Your age is: ' << age << endl; } Sortir
Enter your age: 22 Your age is: 22
Ligne de fin standard (endl)
Le fin est un objet prédéfini de notre ennemi classe. Il est utilisé pour insérer une nouvelle ligne de caractères et vider le flux.
Voyons l'exemple simple d'une ligne de fin standard (endl) :
#include using namespace std; int main( ) { cout << 'C++ Tutorial'; cout << ' Javatpoint'<<endl; cout << 'end of line'<<endl; } < pre> <p> <strong>Output</strong> </p> <pre> C++ Tutorial Javatpoint End of line </pre> <h3>Un-buffered standard error stream (cerr):</h3> <p> <strong> <em>cerr</em> </strong> stands for <strong> <em>'standard error'</em> .</strong> </p> <p>It is an unbuffered stream, meaning that output sent to <strong> <em>cerr</em> </strong> is immediately displayed on the console without buffering.</p> <p>It is typically used for displaying error messages and diagnostic information, which need to be displayed immediately to avoid delays caused by buffering.</p> <p> <strong>Example: using cerr:</strong> </p> <pre> #include int main() { std::cerr << 'This is an error message.' << std::endl; return 0; } </pre> <p> <strong>Output</strong> </p> <pre> This is an error message. </pre> <h3>buffered standard error stream (clog):</h3> <p>clog stands for <strong> <em>'standard log'</em> </strong> . It is a buffered stream, similar to cout. It's often used for writing informational or diagnostic messages that are less time-sensitive than errors. The use of buffering can improve performance when displaying a large number of messages.</p> <p> <strong>Example: using clog</strong> </p> <pre> #include int main() { std::clog << 'This is an informational message.' << std::endl; return 0; } </pre> <p> <strong>Output</strong> </p> <pre> This is an informational message. </pre> <p>In both examples, the output will appear on the console. However, the main difference between <strong> <em>cerr</em> </strong> and <strong> <em>clog</em> </strong> lies in their buffering behavior. Due to its unbuffered nature, messages given to <strong> <em>cerr</em> </strong> are displayed right away, but messages sent to clog may be buffered for greater speed. However, they will still eventually appear on the console.</p> <h4>Note: It is important to remember that the type of message you wish to display will determine whether you use cerr or clog. Use cerr for essential messages that need immediate attention (like error messages) and use clog for less critical diagnostic or informational messages that can be buffered for better performance.</h4> <hr></endl;> Flux d'erreurs standard sans tampon (cerr) :
cerr représente 'erreur standard' .
Il s'agit d'un flux sans tampon, ce qui signifie que la sortie envoyée vers cerr est immédiatement affiché sur la console sans mise en mémoire tampon.
Il est généralement utilisé pour afficher des messages d'erreur et des informations de diagnostic, qui doivent être affichés immédiatement pour éviter les retards causés par la mise en mémoire tampon.
Exemple : en utilisant cerr :
#include int main() { std::cerr << 'This is an error message.' << std::endl; return 0; } Sortir
This is an error message.
flux d'erreurs standard mis en mémoire tampon (obstruction) :
sabot signifie 'journal standard' . Il s'agit d'un flux tamponné, similaire à cout. Il est souvent utilisé pour rédiger des messages d’information ou de diagnostic moins urgents que les erreurs. L'utilisation de la mise en mémoire tampon peut améliorer les performances lors de l'affichage d'un grand nombre de messages.
Exemple : utiliser un sabot
#include int main() { std::clog << 'This is an informational message.' << std::endl; return 0; } Sortir
This is an informational message.
Dans les deux exemples, la sortie apparaîtra sur la console. Cependant, la principale différence entre cerr et sabot réside dans leur comportement tampon. En raison de sa nature sans tampon, les messages transmis à cerr sont affichés immédiatement, mais les messages envoyés à clog peuvent être mis en mémoire tampon pour une plus grande vitesse. Cependant, ils finiront quand même par apparaître sur la console.