Programmation C++/Les entrées-sorties

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


Classes de gestion des flux[modifier | modifier le wikicode]

Les entrées et sorties sont gérées par deux classes définies dans le fichier d'en-tête <iostream> :

  • ostream (Output stream) permet d'écrire des données vers la console, un fichier, ... Cette classe surdéfinit l'opérateur <<.
  • istream (Input stream) permet de lire des données à partir de la console, d'un fichier, ... Cette classe surdéfinit l'opérateur >>.

Flux standards[modifier | modifier le wikicode]

Trois instances de ces classes représentent les flux standards :

  • cout écrit vers la sortie standard,
  • cerr écrit vers la sortie d'erreur,
  • clog écrit vers la sortie technique,
  • cin lit à partir de l'entrée standard (jusqu'au premier espace exclu, éventuellement). Demander un nombre et y entrer des lettres provoque une erreur.
  • getline lit à partir de l'entrée standard (tout).

Ces objets sont définis dans l'espace de nom std.

Exemple[modifier | modifier le wikicode]

#include <iostream>

using namespace std;
 
int main()
{
    int n;
    cout << "Entrez un nombre positif : ";
    cin >> n;
    if (n<0) cerr << "Erreur: Le nombre " << n
                  << " n'est pas positif " << endl;
    else cout << "Vous avez entré " << n << endl;
    return 0;
}

Autres types de flux[modifier | modifier le wikicode]

Les instances des classes dérivées des classes istream et ostream sont également manipulés avec les opérateurs << et >>. Cependant, il ne faut pas oublier de les fermer en appelant la méthode close().

Note: Les noms de fichiers sont codés sur 8 bits sous Linux/Unix et sur 16 bits sur Windows, ce qui peut induire des problèmes de portabilité, le cas échéant.

Flux de fichier[modifier | modifier le wikicode]

La classe ifstream permet de lire à partir d'un fichier. Le constructeur a la syntaxe suivante :

ifstream(const char* filename, openmode mode=in)

Le paramètre mode peut être une combinaison des valeurs suivantes :

app
(append) Placer le curseur à la fin du fichier avant écriture.
ate
(at end) Placer le curseur à la fin du fichier.
binary
Ouvrir en mode binaire plutôt que texte.
in
Autoriser la lecture.
out
Autoriser l'écriture.
trunc
(truncate) Tronquer le fichier à une taille nulle.

Exemple 1 : lire un entier depuis un fichier

ifstream fichier("test.txt");
int a;
fichier >> a; // lire un entier
cout << "A = " << a;
fichier.close();

Exemple 2 : afficher tous les caractères d'un fichier

ifstream fichier("test.txt");
while (fichier.good())
    cout << (char) fichier.get();
fichier.close();

La classe ofstream permet d'écrire vers un fichier. Son constructeur a une syntaxe similaire :

ofstream(const char* filename, openmode mode=out|trunc)

Exemple :

ofstream fichier("test.txt");
fichier << setw(10) << a << endl;
fichier.close();

La classe fstream dérive de la classe iostream permettant à la fois la lecture et l'écriture. Cette dernière (iostream) dérive donc à la fois de la classe ostream et de la classe istream. Son constructeur a la syntaxe suivante :

fstream(const char* filename, openmode mode=in|out)

Exemple :

fstream fichier("test.txt");
fichier << setw(10) << a << endl;
fichier.seekg(0, ios_base::beg);
fichier >> b;
fichier.close();

Flux de chaîne de caractères[modifier | modifier le wikicode]

Ces flux permettent d'écrire pour produire une chaîne de caractères, ou de lire à partir d'une chaîne de caractères.

La classe istringstream dérivée de istream permet de lire à partir d'une chaîne de caractères, et possède deux constructeurs :

istringstream ( openmode mode = in );
istringstream ( const string & str, openmode mode = in );

Exemple :

int n, val;
string stringvalues;
stringvalues = "125 320 512 750 333";
istringstream iss (stringvalues, istringstream::in);

for (n = 0; n < 5; n++)
{
    iss >> val;
    cout << val << endl;
}

La classe ostringstream dérivée de ostream permet d'écrire pour créer une chaîne de caractères, et possède également deux constructeurs :

ostringstream ( openmode mode = out );
ostringstream ( const string & str, openmode mode = out );

Le second permet de spécifier le début de la chaîne de caractères produite.

La méthode str() retourne la chaîne de caractères produite.

Exemple :

ostringstream oss (ostringstream::out);
int a = 100;
oss << "Test d'écriture a=" << a << "\n";
cout << oss.str();

La classe stringstream dérivée de iostream permet d'écrire et lire, et possède deux constructeurs :

stringstream ( openmode mode = in | out );
stringstream ( const string & str, openmode mode = in | out );

Exemple :

int n, val;
stringstream ss (stringstream::in | stringstream::out);

// écriture
ss << "120 42 377 6 5 2000";

// lecture
for (int n = 0; n < 6; n++)
{
    ss >> val;
    cout << val << endl;
}

Manipulateurs[modifier | modifier le wikicode]

Le fichier d'en-tête <iomanip> définit des manipulateurs de flux tels que endl, hex. Ces manipulateurs modifient la façon d'écrire ou lire les données qui suivent celui-ci.

Manipulateur endl[modifier | modifier le wikicode]

Ce manipulateur écrit un retour à la ligne dans le flux, quel qu'il soit (\r\n pour Windows, \n pour Unix/Linux, \r pour Mac, ...). Il est donc conseillé de l'utiliser au lieu du/des caractère(s) correspondant(s), si la portabilité de votre application joue un rôle important.

Exemple:

cout << "Une première ligne" << endl << "Une deuxième ligne" << endl;

N.B.: Certains compilateurs C++ (notamment Visual C++) ne supporte pas que le manipulateur endl soit suivi d'autres données à écrire. Dans ce cas, il faut écrire les données suivantes dans une nouvelle instruction :

cout << "Une première ligne" << endl;
cout << "Une deuxième ligne" << endl;

Manipulateur hex[modifier | modifier le wikicode]

Ce manipulateur indique que les prochains entiers sont à lire ou écrire en base hexadécimale.

Manipulateur dec[modifier | modifier le wikicode]

Ce manipulateur indique que les prochains entiers sont à lire ou écrire en base décimale.

Manipulateur setbase(base)[modifier | modifier le wikicode]

Les 2 manipulateurs précédents sont des alias de celui-ci, qui permet de spécifier la base des prochains entiers à lire ou écrire.

Exemple :

int a = 200; // 200 en décimal

cout << "Valeur de a en base 16 = " << setbase(16) << a << endl;
// affiche:  Valeur de a en base 16 = C8

cout << "Valeur de a en base 10 = " << setbase(10) << a << endl;
// affiche:  Valeur de a en base 10 = 200

cout << "Valeur de a en base 8 = " << setbase(8) << a << endl;
// affiche:  Valeur de a en base 8 = 310

Manipulateur setw(width)[modifier | modifier le wikicode]

Ce manipulateur indique que les prochaines données doivent être écrites sur le nombre de caractères indiqué, en ajoutant des caractères espaces avant.

Exemple :

int a = 11;
cout << "Valeur de a = " << setw(5) << a << endl;

Ce code affiche :

Valeur de a =    11

Manipulateur setfill(char)[modifier | modifier le wikicode]

Ce manipulateur modifie le caractère utilisé pour compléter les données utilisant le manipulateur setw.

Exemple :

int a = 11;
cout << "Valeur de a = " << setfill('x') << setw(5) << a << endl;

Ce code affiche :

Valeur de a = xxx11

Manipulateur setprecision(digits)[modifier | modifier le wikicode]

Ce manipulateur spécifie que les prochains nombres à virgule flottante doivent être écrits avec la précision donnée. La précision donne le nombre maximum de chiffres à écrire (avant et après la virgule).

Exemple :

double f = 3.14159;
cout << setprecision (5) << f << endl;
cout << setprecision (9) << f << endl;

Ce code affiche :

3.1416
3.14159

Manipulateurs setiosflags et resetiosflags[modifier | modifier le wikicode]

Le manipulateur setiosflags (resp. resetiosflags) active (resp. désactive) des options de format des données.

Ces deux manipulateurs possèdent un argument dont le type est défini par l'énumération ios_base::fmtflags. Cet argument peut être :

ios_base::boolalpha
Ecrire/lire les données de type bool sous forme textuelle, càd true ou false.
ios_base::oct
Ecrire/lire les entiers en base octale (base 8).
ios_base::dec
Ecrire/lire les entiers en base décimale (base 10).
ios_base::hex
Ecrire/lire les entiers en base hexadécimale (base 16).
ios_base::showbase
Faire précéder les entiers par leur base.
ios_base::showpos
Faire précéder les nombres positifs du signe plus ( + ).
ios_base::showpoint
Toujours écrire la virgule des nombres réels.
ios_base::fixed
Ecrire les nombres réels avec une virgule fixe.
ios_base::scientific
Ecrire les nombres réels sous forme scientifique.
ios_base::left
Aligner les donnés à gauche (setw).
ios_base::right
Aligner les donnés à droite (setw).
ios_base::internal
Aligner les donnés en remplissant à une position interne (setw).
ios_base::skipws
Ignorer les caractères blancs avant de lire les données.
ios_base::unitbuf
Vider le buffer de sortie à chaque écriture.
ios_base::uppercase
Ecrire les données en majuscules.