14. Les entrées/sorties (Streams ou flots).

14.1 Rappels

Les streams sont déclarés dans le fichier entête iostream.h

14.2 La classe ostream : classe des flots de sortie.

Elle surdéfinit l’opérateur << (insertion) sous la forme d’une fonction membre pour écrire toute
valeur de type prédéfini du langage :
cout << char, entier, long, réel, char *, adresse, …

 L’opérateur << renvoie une référence sur le flot, ce qui permet de cumuler les sorties.

int i = 3;
char c = ‘a’;
char s[] = " bonjour  ";

cout << "i ="  << i << "c="  << c << "s="  << s << ‘\n’ ;

14.2.1 Redéfinition de l'opérateur <<

Pour écrire dans un flot un objet de type T avec l’opérateur <<, il suffit de définir une fonction
amie dans la classe T correspondant à l’une des formes suivantes :

ostream & operator << ( ostream &, T )

ostream & operator << ( ostream &, T& )
ostream & operator << ( ostream &, const T& )

exemple :

ostream & operator << ( ostream &o, const Complex &c )

{
return o << c.x << ‘+’ << c.y << ‘i’ ;
}
Complex z( 2, 3 );
cout << z ; // écrit 2+3i

14.2.2 Autres fonctions de la classe ostream :

ostream &write( char *texte, int n ) Ecrit le tableau jusqu'à la taille n.

cout.write( "maison" , 5 ) ; // écrit : maiso

Page 1 sur 9
ostream &put( char c ) Ecrit le caractère.

cout.put( '\n' ) ; // effectue un saut de ligne

ostream &flush( ) Vide le buffer de sortie.

Page 2 sur 9
14.3 La classe istream : classe des flots d’entrée.

1. Elle surdéfinit l’opérateur >> (extraction) sous la forme d’une fonction membre pour lire
toute valeur de type prédéfini du langage.

 L’opérateur >> renvoie une référence sur le flot, ce qui permet de cumuler les entrées.

int i ;
char c ;

cin >> i >> c ;

 Pour lire un objet d’un nouveau type T dans un flot d’entrée avec l’opérateur >>, il suffit de
définir une fonction amie :

istream & operator >> ( istream &, T& )

istream & operator >> ( istream &i, Complex &c )

{
char carac;
i >> c.x >> carac;
assert( carac == ‘+’ );
i >> c.y >> carac;
assert( carac == ‘i’ );
return i;
}

Complex z ;
cin >> z ; // il faut taper par exemple 2 + 3i

14.3.1 Fonctionnement de l'opérateur d'extraction >>

 Saisie d'un tableau de char :
"saute" les blancs au début
arrête la saisie dès le premier séparateur trouvé,
les autres caractères restent dans le flux, dont le séparateur.
ATTENTION : n'arrête pas la saisie si le tableau de saisie est plein !

char texte [ 50 ] ;
cin >> texte ;
// si on frappe " saisie de mot " ( = Entrée)
// alors texte contient "saisie"
// et il reste " de mot  " dans le flux d'entrée.

 saisie d'un entier :

Page 3 sur 9
 "saute" les blancs au début
arrête la saisie dès le premier caractère différent d'un chiffre

int i ;
cin >> i ;
// si on frappe " 123A" ou " 123 "
// alors i contient 123
// et il reste "A" ou le caractère "" (Entrée seul)

 saisie d'un réel :

"saute" les blancs au début
arrête la saisie dès le premier caractère différent d'un chiffre ou d'un point

double d ;
cin >> d ;
// si on frappe " 3.14A" ou " 3.14 "
// alors d contient 3.14
// et il reste "A" ou le caractère "" (Entrée seul)

 En conclusion cin >>

ne permet pas de saisir des espaces
Le séparateur de fin de saisie reste dans le flux
Il est bon de vider le flux avant ou après une saisie (avec get() ou getline() )
Le fonctionnement est similaire avec scanf().

14.3.2 Autres fonctions de la classe istream :

 La fonction get() : plusieurs formes

int get();
rend le premier caractère du flux sous la forme d'un entier, les autres restent dans le flux.

istream& get(char*, int len, char terminal= '\n');

prend les caractères dans le flux
s'arrête
quand la longueur len – 1 est atteinte et ajoute '\0' dans la saisie
ou quand on rencontre le caractère terminal.
Le caractère terminal reste dans le flux et ajoute '\0' dans la saisie
ne saute pas les "blancs" au début
la saisie contient toujours à la fin le caractère '\0'
les autres caractères restent dans le flux

istream& get(char&);
rend le premier caractère du flux
ctrl Z rend 0.

istream& get(streambuf&, char = '\n');

 La fonction getline()

Page 4 sur 9
istream& getline(char*, int len, char terminal= '\n');
même comportement que get( char *, int, int ) mais
Le caractère terminal est retiré du flux et remplacé par '\0' dans la saisie
Lit donc un caractère de plus que get( char *, int, int ).

 En conclusion : get( char *, int, int ) et getline( char *, int, int )

Saisissent les espaces (par opposition à cin >> )
Utiliser cin.get( char *, int, int ) puis cin.get() pour retirer le séparateur
ou cin.getline(char *, int, int) qui lit aussi le séparateur.
getline( … ) est plus interessant que get( … )
Fonctionnement un peu similaire à gets() mais dans gets : pas de contrôle de la taille du
buffer, le caractère terminal est remplacé par '\0' (comme getline() ).

 La fonction gcount()
int gcount ( );
Renvoie le nombre de caractères saisis par get et getline (et read)
(avec getline on lit un caractère de plus car le caractère terminal est retiré du flux)

char texte[ 50 ] ;
int i ;
i = cin.get() ;
// si on frappe "56"
// alors i contient 0x35 et il reste "6"

cin.get( texte, 5) ; i = cin.gcount()

// si on frappe "123"
// alors texte contient "123" i contient 3 et il reste ""

cin.get( texte, 5) ; i = cin.gcount()

// si on frappe "12345678"
// alors texte contient "1234" i contient 4 et il reste "5678"

cin.getline( texte, 5) ; i = cin.gcount()

// si on frappe "123"
// alors texte contient "123" i contient 3 et il ne reste rien

cin.getline( texte, 5) ; i = cin.gcount()

// si on frappe "12345678"
// alors texte contient "1234" et i contient 4 et il reste "5678"

 La fonction read()
istream& read(char*, int len);
même comportement que get( char *, int, int ) mais
n'utilise pas de caractère terminal.
Peu intéressant.

 La fonction peek()
int peek( );
Rend le caractère dans le flux sans l'extraire.

Page 5 sur 9
Les fonctions tellg() et seekg()

14.4 Le statut d’erreur d’un flot

Ensemble de bits d’un entier :
les bits d’erreur sont définis comme constante dans la classe ios.
ios::eofbit
ios::failbit
ios::badbit
ios::goodbit.

Pour lire tout le statut : int rdstate().

pour modifier le statut : void clear( int = 0)

fl.clear( ios::badbit | fl.rdstate() ) ; // active le bit ‘bad’

fonctions d'état :
bool good() ;
bool fail() ;
bool eof() ;

14.5 Formatage.

Le formatage est effectuée à l’aide de manipulateurs

Il faut inclure le fichier entête <iomanip.h>
Les manipulateurs sont inclus dans le flot.

Quelques exemples : (les manipulateurs sont très nombreux).

dec : conversion en décimale

hex : conversion en hexadécimale
oct :
setbase( int )
fixed , scientific : notation fixe ou scientifique
endl : insère un saut de ligne et vide le tampon
setw( int ) définit le gabarit. A utiliser avant chaque opération !
setprecision( int ) définit la précision des nombres flottants.
setfill( int ) définit le caractère de remplissage. A utiliser avant chaque opération !

int i = 16;
float x = 12.3456;

cout << ‘*’ << hex << i << ‘*‘ << setw( 8 ) << setprecision( 2 ) << x << ‘*’;
// affiche *10* 12.35*

Page 6 sur 9
14.6 Les flux fstream : les fichiers (ofstream, ifstream)

14.6.1 Mode d'ouverture

ios::in en entrée (lecture)
ios::out en sortie (écriture) (détruit le fichier existant)
ios::app en ajout à la fin (conserve le fichier existant)
ios::trunc efface le contenu à l'ouverture ????
ios::binary en mode binaire (utiliser read et write)

14.6.2 Constructeur
fstream( const char *name, int mode, int prot = …. );
ifstream( const char *name, int mode = ios::in );
ofstream( const char *name, int mode = ios::out | ios::trunc );

14.6.3 Autres membres

void ifstream::open( const char *name, int mode = ios::in );
void ofstream::open( const char *name, int mode = ios::in | ios::trunc );
bool fstream::is_open() ;
void fstream::close() ;
void fstream::eof() ;

14.6.4 En écriture on peut utiliser

<< avec tout type de base
put( char )
write( char *, int n) // écrit n caractères, ne s'arrête pas en '\n' ou '\0' !
flush()

14.6.5 En lecture on peut utiliser

>> avec tout type de base
get ( )
get ( char *, int )
getline( char *, int )
long tellg()
seekg( pos )
count() pour connaître le nombre de caractères lu

14.6.6 exemple :
#include <fstream.h>

char ligne[ 80 + 1] ;
char nomFichier[ ] = " …….." ;

ifstream fEntree;
fEntree.open( nomFichier, ios::in );
if( !fEntree.good() ) {
cerr << "erreur ….. " ;
return ;

Page 7 sur 9
}
while( … ) {
fEntree.getline( ligne, 80 + 1, '\n' );
if( fEntree.eof() || fEntree.fail() ) break ;
int taille = fEntree.gcount( ) – 1 ;
……
}
fEntree.close() ;

14.7 Les flux strstream : les chaînes de caractères

14.7.1 Mode d'ouverture

ios::in en entrée (lecture)
ios::out en sortie (écriture) (détruit la chaîne existante)
ios::app en ajout à la fin (conserve la chaîne existante)
ios::trunc efface le contenu à l'ouverture ????
ios::binary en mode binaire (utiliser read et write)

14.7.2 Constructeur
strstream( ) ; utilise un buffer alloué dynamiquement
strstream( signed char *buf, int sz, int mode ); utilise le buffer proposé

14.7.3 Autres membres

char *str() ; retourne le buffer et le gèle
istrstream &getline( char *, int, int )

14.7.4 En écriture on peut utiliser

<< avec tout type de base
put( char )
write( char *, int )
flush()

14.7.5 En lecture on peut utiliser

>> avec tout type de base
get ( )
get ( char *, int )
getline( char *, int )
long tellg()
seekg( pos )
count() pour connaître le nombre de caractères lu

strstream chaîne ;

int i = 5 ;
double d = 3.14 ;

chaine << " i = " << i << " d = " << d ; // équivalent à sprintf()

Page 8 sur 9
chaine << " fin "

cout << chaine.str() ;

Page 9 sur 9