Faculté Informatique & Communications
Cours d'informatique
 EPFL

Mini-Référence :
Flots en C++

Bases

Les types ifstream (flot d'entrée depuis fichier) et ofstream (flot de sortie vers fichier) sont disponibles après l'inclusion du fichier de définition : 
#include <fstream>
Le mécanisme général pour la mise en oeuvre d'entrées-sorties est alors le suivant :

Exemple de lecture à partir d'un fichier

#include <iostream> #include <fstream> #include <string> using namespace std; main() { ifstream fichier; // déclaration du flot en lecture string nom_fichier("test"); fichier.open(nom_fichier.c_str()); // le flot est lié au fichier "test" if (! fichier.fail()) { string mot; while (!fichier.eof()) { fichier >> mot; /* lecture d'un mot dans le * fichier, et affectation à la * variable "mot" */ if (! fichier.fail()) // on a effectivement pu lire qqchose cout << mot; } fichier.close (); // fermeture du flot } else { cout << "Ouverture du fichier " << nom_fichier << " impossible." << endl; } }

Exemple d'écriture dans un fichier

#include <iostream> #include <fstream> #include <string> using namespace std; main() { ofstream fichier; // déclaration du flot en écriture string nom_fichier("test"); fichier.open(nom_fichier.c_str()); // le flot est lié au fichier "test" if (fichier.fail()) { cerr << "erreur ouverture fichier test" << endl; } else { // écriture dans le fichier fichier << 1 << " texte " << 0.75 << endl; // écrit "1 texte 0.75" fichier.close (); // fermeture du flot } }

L'argument de la méthode open ne peut malheureusement pas être de type string !

  Solution : Utiliser la méthode c_str() du type string. fichier.open( nom.c_str() );

Les entrées/sorties formatées

Les manipulateurs:

Pour utiliser les manipulateurs, vous devez inclure la ligne 
#include <iomanip>
dans l'entête de votre fichier.

Les manipulateurs s'utilisent avec cout ou cin comme des expressions à afficher : 

cout << manipulateur << expression << ... << manipulateur << expression ...;

Exemples de manipulateurs :
setprecision(int dg) indique le nombre de chiffres après la virgule pour l'affichage de réels (dg chiffres).
setw(int size) indique la largeur de la chaîne de caractère en entrée/sortie (largeur size).
Utilisé avec cout la chaîne en sortie sera affichée sur size caractères
Utilisé avec cin, permet de lire size caractères à chaque fois.
setfill(char c) sur cout, utilise le caractère c pour effectuer les alignements avec setw.
ws (white space) lors d'une opération d'entrée, saute les espaces (espace, tabulation, retour de ligne, ... ) :
positionne le flot d'entrée sur le prochain caractère non blanc.
dec affiche les nombres en décimal.
hex affiche les nombres en hexadécimal (base 16).
oct affiche les nombre en octal (base 8).

Exemples :

cout << setw(10) << x;
Ceci affiche la valeur de x sur une largeur de 10 caractères. Si plus de caractères sont nécessaires, ils sont ajoutés en nombre juste suffisant pour l'affichage.

Note : Le manipulateur setw() a une caractéristique unique. Alors que les autres manipulateurs sont des options permanentes (les changements affectent toute la suite des entrées/sorties), la largeur indiquée par setw() est valide seulement pour l'objet suivant dans le flot d'entrée/sortie. Dés que cet objet est affiché, la valeur de la largeur d'affichage revient à la valeur par défaut (0). 

string code;
cin >> setw(5) >> code;
Lit uniquement 5 caractères. 

cout << hex << 123 << endl;
affiche 7b.

Les options :

En plus des manipulateurs de flots, certains aspects des formats d'affichage peuvent être contrôler par diverses options que l'on modifie à l'aide la fonction spécifique setf : 
flot.setf(ios::option);
Pour supprimer une option, faire : 
flot.unsetf(ios::option);
Voici les principales options :
ios::showbase affiche la base choisie pour l'affichage, collée aux nombres afficher : rien pour la base décimale, 0x pour l'hexadécimal et 0 pour l'octal.
ios::showpoint affiche toujours la virgule des nombre réels, même lorsqu'ils sont entiers.
ios::fixed affiche les nombres réels en format fixe (normal).
ios::scientific affiche les nombre réels en format "scientifique", c'est-à-dire avec une puissance de 10.
ios::left (avec setw) effectue l'alignement à gauche plutôt qu'à droite.

Une autre façon d'utiliser les flots

Lire une ligne entière

L'opérateur >> lit par défaut jusqu'au prochain caractère blanc (espace, tabulation, retours de ligne, ... ). Il ne permet donc pas de lire une phrase (plusieurs mots) en une fois.

On peut pour cela utiliser getline, qui lit une ligne entière 

string chaine;
getline(flot, chaine);

Lire/Ecrire caractère par caractère
cout.put(char ch) affiche un caractère en sortie.
cin.get(char ch) lit un caractère en entrée.

Exemple :

while (cin.get(ch)) cout.put(ch);
Note : la commande cin.get peut être utilisée lorsque le programmeur veut lire aussi les espaces sur un flot d'entrée. Dans son fonctionnement normal, l'opérateur >> ne lit pas les espaces (e.g. "a b c    d e" est lu comme "abcde"). Par contre, le code dans l'exemple ci-dessus écrit en sortie les caractères lus en entrée les uns après les autres.

Dernière mise à jour : $Date: 2006/10/03 11:16:30 $   ($Revision: 1.1.1.1 $)