EPFL
Faculté Informatique & Communications
Cours d'informatique

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()
{
  string nom_fichier("test");
  ifstream fichier;          // déclaration du flot en lecture
  fichier.open(nom_fichier); // le flot est lié au fichier "test"
  /* ces 2 dernières lignes peuvent être regroupées en :
   * ifstream fichier(nom_fichier);
   */

  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()
{
  string nom_fichier("test");
  ofstream fichier;          // déclaration du flot en écriture
  fichier.open(nom_fichier); // le flot est lié au fichier "test"
  /* ces 2 dernières lignes peuvent être regroupées en :
   * ofstream fichier(nom_fichier);
   */

  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
  }
}

Les entrées/sorties formatées

Pour encore plus de détails sur les options et les manipulateurs, voir ici.

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 à afficher (partie entière et partie fractionnaire) pour les nombres réels (dg chiffres).
setw(int size) indique la largeur de la chaîne de caractères 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. [dans une boucle lisant des char via >>,] «a b c    d e» donnera le même résultat de lecture que «abcde»). Par contre, le code dans l'exemple ci-dessus [qui utilise get()] écrit en sortie tous les caractères lus en entrée, les uns après les autres.
Dernière mise à jour : $Date: 2015-12-03 15:21:52 +0100 (jeu, 03 déc 2015) $   ($Revision: 229 $)