ENTREES / SORTIES

 

Comme pour le C une bibliothèque d'entrée/sortie qui est ainsi portable et efficace.

La librairie d'E/S du CH : iostream

Comme sous UNIX un fichier est une séquence d'octets, sans notion de type, c'est la librairie qui fait la conversion. C'est le programmeur qui donne/définit la structure du fichier en une séquence de valeurs typées.

Quatre descripteurs de flot standard :

Cin // istream lié à l'entrée standard
cout // ostream lié à la sortie standard
cen // ostream lié à la sortie erreur standard
clog // ostream Buffeurisé et lié à la sortie erreur standard
Deux opérateurs prédéfinis sur les types prédéfinis :
>> opérateur de lecture
<< opérateur d'écriture.
 

Définir ses propres fonctions d'entrée / sortie

La conception des entrées/sorties du C++ a pour objectif de fournir une syntaxe qui permet au programmeur d'écrire des fonctions d'entrée/sortie sur les nouveaux types.

Deux approches : les entrées/sorties lisibles avec une conversion en ascii, c'est à dire la philosophie scanf/printf qui a ses avantages mais qui est surtout prévue pour les interactions avec un utilisateur.

L'autre approche est le couple read/write (fread/f write) où l'avantage est de simplifier l'écriture, mais les fichiers de données ne sont plus portables d'une machine à l'autre.

 

Attention à la précédence de << et >>
Cont << val 1 > val 2 ? val 1 : val 2 ;
( )
 

Entrée de valeur, on retrouve les mêmes comportements que scanf qui consomme les espaces. Pour lire les espaces on utilisera get

char c ;
cin.get (c) ; // lecture des espaces
cin >> c ; // les espaces ne sont pas pris en compte.
Ce comportement nous définit une règle simple pour l'écriture de l'opérateur >> qui est d'écrire un espace après chaque valeur, ce qui nous assure un découpage correcte à la relecture avec <<.

Il reste toujours la possibilité de travailler en binaire avec :

cin.read (char*addr, int size) ;
et
cont.write (char*addr, int size) ;
 

Ouverture de flot

Les flots utilisateurs sont de type fstream # include < fstream.h)

ifstream ouverture en lecture par défaut.
ofstream ouverture en écriture par défaut.

Les 2 types ont un constructeur qui prend le nom de fichier en premier paramètre, le deuxième argument précise les autres modes d'ouverture.

 
Class ios {  
Public :  
erreur open - mode {
in = 1 // lecture
out = 2 // écriture
ate = 4 // pointeur à la fin  
app = 010, // mode append
trunc = 020, // écrasement
nocreate = 040,  
moreplace = 0100  
}  
...  
} ;  
Un exemple
ofstream monstream ("/unix", ias :: out/ias :: nocreate) ;
fstream Bob ("concorde", ias :: out/ias :: in ) ;
 

Conditions d'erreur et fin de fichier

La formule magique du C :
           int c ;
           while ((c = get char ()) ! = EOF) {---}
S'écrit
           char c ;
           while (cin.>>c) {---}
mais il est possible d'écrire
           int c ;
           while ((ch = cin.get ()) ! = EOF) { }
pour les nostalgiques.

Iastream inOut ;
           eof () vrai si fin de fichier for (;;) { if (inout.eof ( )) break ; }
           bad () vrai si condition d'opération invalide : mouvement avant le fichier.
           Fail () vrai en cas d'échec d'une opération
                     ifstream ifile (pathname, ios :: in) ;
                     if (ifile-fail ()) even ("ouverture impossible") ;
           good () vrai si ni eof (), ni bad (), ni fail ()

 

Un test d'ouverture if (ifile.rdhuf ()® is open) // ok ouvert !

 

Héritage