Programmation C++/Les entrées-sorties

Les opérations de base

Les pointeurs

Programmation C++

Annexes

Dessiner des formes : les bibliothèques graphiques

Anciennes pages

Version imprimable

[ Modifier le sommaire ]

Les opérations de base

Les pointeurs

Classes de gestion des flux

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

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

#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

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

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

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

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`

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`

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

Manipulateur `dec`

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

Manipulateur `setbase(base)`

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)`

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)`

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)`

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`

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: Écrire/lire les données de type bool sous forme textuelle, càd true ou false.
ios_base::oct: Écrire/lire les entiers en base octale (base 8).
ios_base::dec: Écrire/lire les entiers en base décimale (base 10).
ios_base::hex: Écrire/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: Écrire les nombres réels avec une virgule fixe.
ios_base::scientific: Écrire 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: Écrire les données en majuscules.

Cette section est vide, pas assez détaillée ou incomplète. Votre aide est la bienvenue !

Programmation C++/Les entrées-sorties

Classes de gestion des flux

Flux standards

Exemple

Autres types de flux

Flux de fichier

Flux de chaîne de caractères

Manipulateurs

Manipulateur endl

Manipulateur hex

Manipulateur dec

Manipulateur setbase(base)

Manipulateur setw(width)

Manipulateur setfill(char)

Manipulateur setprecision(digits)

Manipulateurs setiosflags et resetiosflags

Manipulateur `endl`

Manipulateur `hex`

Manipulateur `dec`

Manipulateur `setbase(base)`

Manipulateur `setw(width)`

Manipulateur `setfill(char)`

Manipulateur `setprecision(digits)`

Manipulateurs `setiosflags` et `resetiosflags`