M1103—Cours de C++ (3)

{ A. Casali / M. Laporte
• Exam de vendredi (quand, quoi)
• Evaluation des enseignements
• Projet
Plan
A. Flux de sortie

B. Flux d’entrée

C. Gestion des erreurs de lecture

D. Positionnement dans un flux

E. Etat d’un flux

F. Classe stringstream
A. Flux de sortie
On souhaite écrire le résultat de l’application dans un fichier de sortie

Solution 1 : rediriger la sortie standard vers un fichier

a.out > OutFile

Problèmes :
• Comment fait-on si on souhaite écrire dans un fichier depuis une
interface graphique (ie, on n’a pas accès à la console);
• Comment peut on écrire dans plusieurs fichiers en même temps (on ne
peut faire que 2 redirections : la sortie standard et le flux d’erreur).

Solution 2 : utiliser les flux de sortie

A.1 Declaration

#include <fstream>
using namespace std;

ofstream ofs;

Output File STREAM

A.2 Ouverture

ofs.open (string FileName [, Mode XXX]);

On lie le flux de sortie ofs au fichier FileName selon le mode spécifier.
La chaine FileName est le chemin relatif au fichier souhaité. Le « point de
départ » du chemin relatif est l’exécutable.
Par défaut (aucun mode n’est spécifié) :
• Le fichier texte est accessible en écriture;
• Si le fichier n’existe pas, il est créé;
• S’il existe, les informations sont ajoutées avant celles qui existaient déjà.

Exemple :
ofs.open ("test.txt");
A.3 Déclaration et Ouverture

En même temps qu’on déclare un flux sur un fichier, il est possible de spécifier:
• le fichier en question;
• Son mode d’ouverture.

ofstream ofs (string Filename [,Mode XXX]);

Exemple :
ofstream ofs ("test.txt");

A.4 Les modes d’ouverture

Tous les modes sont des constantes de la classe ios_base.

On accède à un mode en utilisant la notation ios_base::ModeName
ModeName Signification Accès
out output (sortie) Accès au flux en écriture
in input (entrée) Accès au flux en lecture
binary binary (binaire) Effectue les opérations
d’E/S en mode binaire et
non en mode texte
ate at end (à la fin) Position la tête (de
lecture) à la fin du
fichier
app append (ajout) Les ajouts se font à la fin
du fichier et non au
début
trunc truncate (troncature) Supprime le contenu du
fichier

Exemple :
ofstream ofs ("test.txt", ios_base::out|ios_base::binary);

Le caractère ‘|’ permet d’enchainer les options.

 Un flux de sortie ne peut avoir, en même temps, les
modes trunc et app!

A.5 Fermeture d’un flux de sortie

On appelle la méthode close () sur le flux de sortie.

Exemple :
ofs.close ();
A.6 Ecriture dans un flux de sortie

On utilise l’injecteur (<<) pour pouvoir écrire dans un flux de sortie,

de la même manière qu’on l’utilise pour pouvoir écrire dans la
console (qui est un cas particulier des flux de sortie).

L’injecteur fonctionne :
• Pour tous les types (int, char, bool, …);
• Pour certaines classes (string).

Exemple :
ofs << 10 << endl;
ofs << true << endl;
ofs << ‘a’ << endl;
ofs << "coucou" << endl;

more test.txt
10
1
a
coucou
 De la même façon qu’on ne peut afficher un vecteur (vector)
sur la console, on ne peut pas l’injecter directement dans un
flux de sortie.

Exemple :
CVInt V (10);
ofs << V;

XXX.cxx:YYY:Z: error: cannot bind 'std::basic_ostream<char>'

lvalue to 'std::basic_ostream<char>&&'
ofs << V;
^
In file included from /opt/local/include/gcc48/c++/iostream:39:0,
from hello.cpp:9:
/opt/local/include/gcc48/c++/ostream:602:5: error: initializing
argument 1 of 'std::basic_ostream<_CharT, _Traits>&
std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const
_Tp&) [with _CharT = char; _Traits = std::char_traits<char>; _Tp
= std::vector<int>]'
operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp&
__x)
^
La seule et unique solution consiste à injecter chaque élément du
vecteur les uns à la suite des autres en utilisant une boucle.

Exemple :
for (int x : V)
ofs << setw (3) << x;

more test.txt
0 0 0 0 0 0 0 0 0 0
Plan
A. Flux de sortie

B. Flux d’entrée

C. Gestion des erreurs de lecture

D. Positionnement dans un flux

E. Etat d’un flux

F. Classe stringstream
B. Flux d’entrée
On souhaite lire des données pour une application depuis un fichier d’entrée

Solution 1 : rediriger l’entrée standard depuis un fichier

a.out < InFile

Problèmes :
• Comment fait-on si on souhaite lire des données depuis le Net (voir
S3);
• Comment peut on lire depuis plusieurs fichiers en même temps (on ne
peut faire qu’une redirections : l’entrée standard).

Solution 2 : utiliser les flux d’entrée

B.1 Declaration

#include <fstream>
using namespace std;

ifstream ifs;

Input File STREAM

B.2 Ouverture

ifs.open (string FileName [, Mode XXX]);

On lie le flux d’entrée ifs au fichier FileName selon le mode spécifier.
La chaine FileName est le chemin relatif au fichier souhaité. Le « point de
départ » du chemin relatif est l’exécutable.
Par défaut (aucun mode n’est spécifié) :
• Le fichier texte est accessible en lecture;
• Si le fichier n’existe pas, il n’est pas créé (aucun contrôle quant à la validité
du fichier est effectué);
• S’il existe, la tête de lecture est positionnée au début du fichier.
Exemple :
ifs.open ("test.txt");
B.3 Déclaration et Ouverture
En même temps qu’on déclare un flux sur un fichier, il est possible de spécifier:
• le fichier en question;
• Son mode d’ouverture.

ifstream ifs (string Filename [,Mode XXX]);

Exemple :
ifstream ifs ("test.txt");

B.4 Les modes d’ouverture

Les différents mode d’ouverture sont les mêmes que pour les flux de sortie.
On ne peut toujours pas associer les mode trunc et ate.
De même l’ouverture échoue si le mode est trunc, mais pas out.

B.5 Fermeture d’un flux d’entrée

On appelle la méthode close () sur le flux d’entrée.

Exemple :
ifs.close ();
B.6 Existence d’un flux d’entrée

On appelle la méthode is_open () sur le flux d’entrée. Cette méthode renvoie

vrai si le flux existe, faux sinon.

Exemple :
if (!ifs.is_open ())
{
cerr << "File not found" << endl;
return;
}
//le fichier existe et est accessible
B.7 Lecture depuis un flux d’entrée

On utilise l’extracteur (>>) pour pouvoir lire depuis un flux d’entrée,

de la même manière qu’on l’utilise pour pouvoir lire depuis le
clavier (qui est un cas particulier des flux d’entrée).
test.txt :
L’extracteur fonctionne : coucou
• Pour tous les types (int, char, bool, …); 10
• Pour certaines classes (string). 1
a
Exemple (1):
string str;
ifs >> str;
cout << str << endl; coucou
int x; 10
ifs >> x;
cout << x << endl;
bool b; 1
ifs >> b;
cout << b << endl;
char c; a
ifs >> c;
cout << c << endl;
Exemple (2) :
test.txt :
0 0 0 0 0 0 0 0 0 0
Tête de lecture

Données non exploitées

int x;
ifs >> x;
cout << x << endl; 0
bool b;
ifs >> b;
cout << b << endl; 0
char c;
ifs >> c;
cout << c << endl; 0
string str;
ifs >> str;
cout << str << endl; 0
B.7 Lecture du contenu d’un fichier

On aimerait avoir un algorithme du type :

tant_que (NON fin_de_fichier)
faire
UnType Resultat <-
lire_quelque_chose;
Manipuler (Resultat);
ffaire
PB : on ne peut détecter la fin d’un fichier qu’après avoir fait
une tentative de lecture.

Solution :
boucle
UnType Resultat <- lire_quelque_chose;
si (fin_de_fichier) sortie;
Manipuler (Resultat);
fboucle
Pour détecter la fin d’un fichier, on appelle la méthode eof () sur le flux
d’entrée. Cette méthode renvoie vrai si la fin d’un fichier a été atteint, faux sinon.

Exemple :
while (true)
{
AType VarIdent = ReadSomething ();
if (ifs.eof ()) break;
Manipulate (VarIdent);
}

Problème (1) :
Lire un vecteur d’entier préalablement stocké

CVInt V;
while (true)
{
int x;
ifs >> x;
if (ifs.eof ()) break;
V.push_back (x);
}
Problème (2) :
Connaître le nombre de mots d’un fichier texte
Commande wc –w sous Linux

unsigned wc (0);
string str;
while (true)
{
ifs >> str;
if (ifs.eof ()) break;
++wc;
}
cout << setw (8) << wc << ' ' << __FILE__ << endl;

Macro du C permettant de connaitre

le nom du fichier courant.
Problème (3) :
Connaitre le nombre de caractères d’un fichier texte
Commande wc –c sous Linux

Solution 1 :
unsigned wc (0);
char c;
while (true)
{
ifs >> c;
if (ifs.eof ()) break;
++wc;
}
cout << setw (8) << wc << ' ' << __FILE__ << endl;

Pb : quid de l’encodage des caractères 

wc -c hello.cxx
wc: hello.cxx: Illegal byte sequence
8230 hello.cxx
./a.out
6414 hello.cxx
Solution 2 : utiliser la méthode get (char &) de la classe ifstream.

unsigned wc = 0;
char c;
while (true)
{
ifs.get (c);
if (ifs.eof ()) break;
++wc;
}
cout << setw (8) << wc << ' ' << __FILE__ << endl;
Problème (4) :
Connaitre le nombre de lignes d’un fichier texte
Commande wc –l sous Linux

Lorsqu’on souhaite lire une ligne complète depuis la console :

~void getline (cin, string &);
Or on souhaite lire depuis un flux d’entrée. Donc :
~void getline (ifstream &, string &);

Le flux est passé par référence car il y a consommation de

l’information (déplacement de la tête de lecture).
unsigned wc = 0;
string str;
while (true)
{
getline (ifs, str);
if (ifs.eof ()) break;
++wc;
}
cout << setw (8) << wc << ' ' << __FILE__ << endl;
En utilisant une boucle for :
unsigned wc = 0;
string str;
for (getline (ifs, str); !ifs.eof (); getline (ifs, str))
++wc;

cout << setw (8) << wc << ' ' << __FILE__ << endl;
Plan
A. Flux de sortie

B. Flux d’entrée

C. Gestion des erreurs de lecture

D. Positionnement dans un flux

E. Etat d’un flux

F. Classe stringstream
C. Gestion des erreurs de
lecture
Ca aurait pu être n’importe quel
C.1 Echec de lecture ifstream, le résultat aurait été le même

int i;
for ( ; ; )
{
cout << "Taper un entier suivi de <CR> : ";
cin >> i;
if (cin.eof ()) break;
cout << "i = " << i << endl;
}
Taper un entier suivi de <CR> : x10
i = 1075991360
Taper un entier suivi de <CR> : i = 1075991360
Taper un entier suivi de <CR> : i = 1075991360
Taper un entier suivi de <CR> : i = 1075991360
...
 1. L’utilisateur n’a pas entré un int;
2. La chaine de caractère "x10" reste dans le tampon;
3. Le tampon n’a pas pu se vider;
4. A chaque tour de boucle, l’extracteur essaye de convertir ce
qu’il y a dans le tampon en un int (retour en 2)

Solution :
Appeler la méthode fail () de la classe istream pour savoir si
l’extraction a pu se faire.

int i; Classe pour tous les flux d’entrée

for (;;){ (cin, ifstream, …)
cout << "Taper un entier suivi de <CR> : ";
cin >> i;
if (cin.eof ()) break;
if (cin.fail ())
cout << "echec de lecture" << endl;
else
cout << "i = " << i << endl;
}
Taper un entier suivi de <CR> : x10
echec de lecture
Taper un entier suivi de <CR> : echec de lecture
Taper un entier suivi de <CR> : echec de lecture
Taper un entier suivi de <CR> : echec de lecture
Taper un entier suivi de <CR> : echec de lecture

1. On a bien détecter l’erreur sur le flux;

2. Mais, le caractère invalide n'étant pas lu, il reste
dans le tampon et est retrouvé à la lecture suivante
 purger le tampon

…
if (cin.fail ())
{
cout << "echec de lecture" << endl;
string Buf;
getline (cin, Buf);
}
même exécution 
même résultat !!!
C.2 Restauration

Pour pourvoir restaurer un flux positionné dans un état fail (), il faut
appeler la méthode clear () sur ce flux.

…
if (cin.fail ())
{
cout << "echec de lecture" << endl;
cin.clear (); = remise en état du flux
string Buf;
getline (cin, Buf);
}
Taper un entier suivi de <CR> : x10
echec de lecture
Taper un entier suivi de <CR> : 10
i = 10
Taper un entier suivi de <CR> : Ctrl+D
Problème : tous les entiers sur la ligne après le caractère invalide sont perdus.

Solution : purger caractère/caractère

C.3 Lecture dans le tampon sans consommation de l’information

On souhaite supprimer tous les caractères invalides du tampon

int i; qui sont avant l’entier à extraire.
for (;;){
cout << "Taper un entier suivi de <CR> : ";
cin >> i;
if (cin.eof ()) break;
if (cin.fail ())
{
cout << "echec de lecture" << endl;
char c;
cin.clear ();
for (cin.get (c); !isdigit (c); cin.get (c));
}
else
cout << "i = " << i << endl
}
Taper un entier suivi de <CR> : xzy10
echec de lecture
Taper un entier suivi de <CR> : i = 0

get () consomme l’information qui est dans le tampon

Solution :
Ne consommer l’information que si elle est invalide.
 On est obligé de lire dans le tampon sans le toucher. Pour cela, il faut utiliser
la méthode peek ().

…
if (cin.fail ())
{
cout << "echec de lecture" << endl;
cin.clear ();
char c;
for (c = cin.peek (); !isdigit (c); c = cin.peek ())
cin.get ();
}

Taper un entier suivi de <CR> : xzy10

echec de lecture
Taper un entier suivi de <CR> : i = 10
Taper un entier suivi de <CR> : Ctrl + D
On souhaite supprimer tous les caractères invalides du tampon qui sont
après la string à extraire.

string email;
cout << "Entrer votre email : ";
cin >> email;
cout << email << endl;
unsigned age;
cout << "Entrer votre age : ";
cin >> age;
cout << age << endl;

Entrer votre email : alain.casali@univ-amu.fr marc.laporte@univ-

amu.fr
alain.casali@univ-amu.fr
Entrer votre age : 0

=> Il faut purger le reste du tampon après avoir fait la lecture.

Solution 1 : utiliser (et adapter) la méthode qui utilise peek ()

Solution 2 : utiliser la méthode ignore () de la classe istream de profil

~void ignore (streamsize n, int delim);

~unsigned (Par défaut 1) Par défaut EOF

1er paramètre : nombre de caractères maximum à ignorer dans le flux

courant. Ces caractères seront supprimés du tampon.
2ème paramètre : ignorer les caractères jusqu’à ce qu’on trouve ce caractère.

string email;
cout << "Entrer votre email : "; On ignore tout le reste du flux
cin >> email;
cout << email << endl;
cin.ignore (numeric_limits<streamsize>::max(), '\n');
unsigned age;
cout << "Entrer votre age : ";
cin >> age;
cout << age << endl;
Plan
A. Flux de sortie

B. Flux d’entrée

C. Gestion des erreurs de lecture

D. Positionnement dans un flux

E. Etat d’un flux

F. Classe stringstream
D. Positionnement dans
un flux
On appelle la méthode seekg () de la classe istream de profil
~void seekg (streamoff, ios_base::seekdir);

1er paramètre : (~int) nombre d’octet du déplacement

2ème paramètre : position à partir de laquelle on fait le déplacement
• ios_base::beg : déplacement à partir du début du flux;
• ios_base::cur : déplacement à partir de la position courante du flux;
• ios_base::end : déplacement à partir de la fin du flux.
 Lecture à l'envers dans un flux

at end

ifstream ios ("Relecture", ios_base::ate | ios_base::in);

if (0 == ios.tellg()) return 0;

ios.seekg (-1, ios_base::cur);

for (char c; ; )
{
cout << ios.tellg();
ios.get (c) ;
cout << ' ' << c << '\n'; 5 5
4 4
if (1 == ios.tellg()) break; 3 3
ios.seekg (-2, ios_base::cur); 2 2
} 1 1
return 0; 0 0
Plan
A. Flux de sortie

B. Flux d’entrée

C. Gestion des erreurs de lecture

D. Positionnement dans un flux

E. Etat d’un flux

F. Classe stringstream
E. Etat d’un flux
Un flux peut avoir 4 états :
• eof () : fin de fichier;
• fail () : erreur E/S
• bad () : erreur sur le flux (propagation d’exception, …)
• good () : le flux est OK

Les 2 tests suivants sont équivalents :

1. if (ifs)
2. if (ifs.good () [==true])

Profil de getline () (amphi 2.2)

~void getline (ifstream &, string &);

Nouveau profil:
ifstream getline (ifstream &, string &);
 Lecture jusqu’à la fin d’un fichier :

string str;
for (getline (ifs, str); !ifs.eof (); getline (ifs, str))
Manipulate (str);

En utilisant le nouveau profil de getline () :

string str;
for ( ; getline (ifs, str);)
Manipulate (str);

Appel sous-jacent à .good () et on

n’effectue l’appel à la fonction uniquement
si le flux est dans un état valide.
Plan
A. Flux de sortie

B. Flux d’entrée

C. Gestion des erreurs de lecture

D. Positionnement dans un flux

E. Etat d’un flux

F. Classe stringstream
F. Classe stringstream
Pour éviter la gestion des erreurs des E/S des utilisateurs, certains langages
(Java, C#, …) ne permettent que de saisir des chaines de caractères. Ensuite
il faut convertir la chaine vers le type en question (par exemple un int).

Exemple C++ :
int x;
cin >> x;
Le flux peut être dans un état invalide

Exemple C#:
int x;
string str = Console.ReadLine ();
if (Int32.TryParse (str, out x));
…
Le flux est toujours dans un état valide
 Se comportent
comme des strings et
comme des streams !!!
#include <sstream>
ostringstream ostr;
ostr << "L'expr 0 == 1 est "
<< boolalpha << (0 == 1) << '\n';
cout << ostr.str(); ou
string S = ostr.str() + "..."; renvoie une copie de la
chaîne
Les manipulateurs marchent 
comment transformer un nombre en string ?
par injection :

ostringstream ostr; Le flux contient :

int UnInt = 12;
ostr << setw (4) << UnInt; " 12"
#include <sstream>
ostringstream ostr ("Flux initial\n"); affiche :
Flux initial
cout << ostr.str() << "#\n"; #

for (int i = 5; --i; ) ostr << i; affiche :

ostr << endl; 4321
initial
cout << ostr.str() << "#\n"; #

écrase le caract. ' ' écrase les 4 caract. Flux

#include <sstream>
ostringstream ostr ("Flux initial\n", ios_base::ate);

for (int i = 5; --i; ) ostr << i;

ostr << endl; affiche :
Flux initial
cout << ostr.str() << "#\n"; 4321
#
 De même avec les istringstreams

#include <sstream>

istringstream istr (ostr.str());

char C;
for (istr.get (C); ! istr.eof(); istr.get (C))
cout << C;

istringstream Nombres ("1 2 3 4 5");

for (int Val; Nombres >> Val; ) cout << Val << '\t';

affiche :

1 2 3 4 5
 Autre utilisation

Port-Saguenay 158 627 456 348 327 350 162 304 327 92 308 0
Port-Menier 152 330 200 107 83 60 147 487 79 293 0
Pointe-au-Pic 126 595 424 355 303 318 131 208 303 0
Percé 191 331 140 28 25 128 194 511 0

Lire le nom de la ville puis un nombre inconnu à l'avance de distances :

string Str;
getline (cin, Str);

istringstream Flux (Str);

string NomVille;
Flux >> NomVille;
vector <unsigned> VDist;

for (unsigned Val; Flux >> Val; ) VDist.push_back (Val);