Fichiers et flux de données - David Saint

Langage C++
Fichiers et flux de données
21/11/02
Les fichiers et flux de données
1
LES MOYENS : 3 CLASSES ................................................................................................................................. 1
1.1
2
OUVRIR ET FERMER UN FICHIER - LES FONCTIONS OPEN () CLOSE().................................................. 1
2.1
2.2
3
ECRITURES NON FORMATÉES PUT() WRITE() ........................................................................................................ 4
LECTURES NON FORMATÉES GET() READ()........................................................................................................... 4
SE DÉPLACER DANS LE FLUX DE DONNÉES TELL(P/G), SEEK(P/G)........................................................................... 4
GÉRER L’ÉTAT DU FLUX................................................................................................................................... 5
5.1
5.2
5.3
6
LIRE DES DONNÉES FORMATÉES AVEC L’OPÉRATEUR D’EXTRACTION >> .............................................................. 3
ECRIRE DES DONNÉES FORMATÉES AVEC L’OPÉRATEUR D’INJECTION <<............................................................... 3
LECTURE ET ECRITURE NON FORMATÉ - SE DÉPLACER DANS LE FLUX............................................ 4
4.1
4.2
4.3
5
LA FONCTION OPEN().......................................................................................................................................... 2
LES MODES D’OUVERTURE .................................................................................................................................. 2
LECTURE ET ÉCRITURE FORMATÉE DES DONNÉES ................................................................................. 3
3.1
3.2
4
CRÉER DES INSTANCES DES CLASSES POUR GÉRER LES FICHIERS ........................................................................... 1
LES FONCTIONS GOOD(), EOF(), FAIL(), BAD() ET CLEAR().................................................................................... 5
DÉTECTER LA FIN DE FICHIER LORS D’UNE OPÉRATION DE LECTURE AVEC >> ....................................................... 6
GÉRER LES ERREURS D’OUVERTURE DE FICHIER................................................................................................... 6
EXEMPLE TRAITEMENT DU FICHIER PIÈCE ............................................................................................... 6
6.1
6.2
STRUCTURE DE DONNÉES.................................................................................................................................... 7
EXEMPLES DE PROGRAMMES............................................................................................................................... 8
7
TABLE DES EXEMPLES DE CODE.................................................................................................................. 10
1
LES MOYENS
IOS
: 3 CLASSES
ISTREAM
Les fichiers peuvent être gérés comme des flux de données
de la même manière que les entrées sorties standards (Voir
Gestion des flux avec *stream). Trois classes sont disponibles :
§ ifstream fichier en lecture seulement
§ ofstream fichier en écriture seulement
IFSTREAM
§ fstream fichier en lecture et écriture.
OSTREAM
IOSTREAM
FSTREAM
OFSTREAM
1.1 Créer des instances des classes pour gérer les fichiers
ifstream fichierEntree ;
ofstream fichierSortie;
fstream fichierES;
// instance d’un flux de données fichier en lecture
// instance d’un flux de données fichier en écriture
// instance d’un flux de données fichier en R/W
Remarque : Si les données contenues dans le fichier, ne sont pas modifiées, le fichier doit être ouvert en lecture
seulement.
2 OUVRIR ET FERMER UN FICHIER - LES FONCTIONS OPEN () CLOSE()
Pour chaque type de fichier, il existe plusieurs
méthodes (fonctions à appliquer), les principales sont :
open () : ouvre un fichier
close(): ferme un fichier ouvert
Ces deux fonctions sont obligataires dans le
programme. Elles associent un flux de données
(stream, tampon, canal) au fichier.
§ open () : Crée un flux (stream) associé à l’objet
fichier. Ensuite les données du flux sont exploitées
David Saint-Mellion
page 1/10
#include <fstream>
using namespace std;
int main(void){
ofstream monFichier;
monFichier.open("mesure.dat");
//---TRAITEMENT--monFichier.close();
return 0;
}
Langage C++
Fichiers et flux de données
21/11/02
close() : Enregistre les données du flux dans le fichier, détruit le flux de données et l’instance du fichier dans
le programme.
Remarque : Par défaut, le destructeur appelle la fonction close().
Exemple Ouvrir Fermer un fichier
Fichier : mesure.dat
1 -Ouvrir : Associe un flux de données au fichier
monFichier.open("mesure.dat");
Flux de données : monFichier
12.5 12
12.9 13 12
13.5 12.1
12.3
12.5 12 12.9 13 12 13.5 12.1 12.3
2 -Traitement : Modifie les données du flux de données
Flux de données : monFichier
Fichier : mesure.dat
12.5 12 12.9 13 12 13.5 12.1 12.3 13.5 11.5
3 - Fermer : Enregistre les données dans le fichier et détruit le flux de données
monFichier.close();
12.5 12
12.5 12
12.9 13 12
13.5 12.1
12.3 13.5
11.5
2.1 La fonction open()
Elle ouvre le fichier et associe un flux de données.
void open(const char *nom, int mode,int prot=filebuf::openprot);
nom : nom du fichier à ouvrir
mode : mode d'ouverture du fichier
prot : il définit les droits d'accès au fichier dans le cas d'une ouverture avec création (sous UNIX).
2.2 Les modes d’ouverture
ios::app
ios::ate
ios::in
ios::out
ios::binary
ios::trunc
ios::nocreate
ios::noreplace
Ajouter toujours les données en fin de fichier
Ouvrir le fichier en écriture avec positionnement à la fin du fichier
Ouverture en lecture (par défaut pour ifstream)
Ouverture en écriture (par défaut pour ofstream)
Ouverture en mode binaire (par défaut en mode texte)
Détruit le contenu du fichier s'il existe (par défaut pour ofstream)
Si le fichier n'existe pas, l'ouverture échoue
Si le fichier existe, l'ouverture échoue, sauf si ate ou app sont activés
Exemples : Ouverture de fichiers open()
#define NOM_FICHIER "mesure.dat"
ifstream fichierPieceE;
// Fichier Pièce en lecture
ofstream fichierPieceS;
// Fichier Pièce en écriture
fstream fichierTmp;
// Fichier Pièce en lecture
// Ouvre le fichier Pièce en lecture
fichierPieceE.open(NOM_FICHIER);
// Ouvre le fichier en écriture avec destruction du contenu
fichierPieceS.open(NOM_FICHIER);
//1
// Ouvre le fichier sans destruction du contenu « Mode ajout à la fin »
// et avec positionnement à la fin du fichier
fichierPieceS.open( NOM_FICHIER,ios::app);
//2
// Ouvre le fichier en R/W et détruit son contenu
fichierTmp.open(FICHIER_TMP,ios::in|ios::out|ios::trunc);
//1
Les modes d’ouverture sont surtout important en écriture. Soit on souhaite :
§ Ajouter des données, le mode naturel est de les insérer à la fin du fichier existant en utilisant les modes
d’ouverture : ios: :app ou ios: :ate //2.
§ Renouveler les données du fichier, il faut alors détruire les données //1.
David Saint-Mellion
page 2/10
Langage C++
Fichiers et flux de données
21/11/02
3 LECTURE ET ECRITURE FORMATEE DES DONNEES
Un flux de données est associé à l’objet fichier. On bénéficie des fonctionnalités des classes iostream (voir
diagramme $1) : Les fonctions, les opérateurs injection << et extraction >> et les manipulateurs de flux de
données qui s’appliquent aussi aux flux de données fichiers.
3.1 Lire des données formatées avec l’opérateur d’extraction >>
Exemple 31 : Lecture formatée avec l’opérateur d’extraction >>
#include <iostream>
#include <fstream>
using namespace std ;
int main(void){
float cote=0 ;
ifstream fMesure;
//Crée un objet flux fichier en lecture
fMesure.open("mesure.dat"); //Ouvre le fichier
fMesure >> cote;
cout<<"La cote de la PIECE 1 vaut : "<<cote<<endl;
fMesure >> cote;
cout<< "la cote de la PIECE 2 vaut : "<<cote<<endl;
fMesure.close();
//Ferme le fichier et le flux
return 0;
}
Remarques
§ L’opérateur d’extraction prélève la donnée dans le flux et l’affecte à cote. De plus, il gère le
déplacement sur l’objet suivant se trouvant dans le flux. Cet opérateur peut être surchargé pour s’adapter
à d’autres types de données que ceux du langage C++.
§ Voir : Gestion des flux avec *stream, surcharge des opérateurs >> et <<
§ Voir : Exemples $6
3.2 Ecrire des données formatées avec l’opérateur d’injection <<
Exemple 32 : Ecriture formatée avec l’opérateur d’injection <<
#include <iostream>
#include <fstream>
using namespace std ;
int main(void){
float cote1=13;
float cote2=13.5;
float cote3=13.8;
ofstream fMesure;
// Instance flux fichier en lecture
// Ouvre le fichier en lecture avec destruction des données
fMesure.open("mesure.dat");
fMesure << cote1<< endl;
fMesure << cote2<< endl;
fMesure << cote3<< endl;
fMesure.close(); // Ferme le fichier et le flux
return 0;
Résultat dans le fichier
}
Remarques
§ L’opérateur d’injection affecte la donnée coteX au flux de données. Le retour chariot endl est
également injecté pour séparer les données. La fonction close() enregistre les données dans le fichier
«mesure.dat».
§ Cet opérateur peut être surchargé pour s’adapter à d’autres types de données que ceux du langage
C++. Pour ajouter les données au fichier existant (à la fin), il faut l’ouvrir en mode app
monFichier.open("mesure.dat",ios::app);
§ Voir : Gestion des flux avec *stream, surcharge des opérateurs >> et <<
§ Voir : Exemples $6
David Saint-Mellion
page 3/10
Langage C++
Fichiers et flux de données
21/11/02
4 LECTURE ET ECRITURE NON FORMATE - SE DEPLACER DANS LE FLUX
4.1 Ecritures non formatées put() write()
Les fonctions pour lire des données dans un fichier sont issues de la classe ostream Voir Gestion des flux avec
*stream.
§ put(char c) Insére le caractère passé en paramètre
§ write(const char*, int n) Insère la chaîne de n caractères, passée en paramètre
Exemple : put()
monFichier.put(‘W’);
// Ecrit le caractère W dans monFichier
Exemples : write()
monFichier.write("Dupont",6);
// Ecrit Dupont dans monFichier
const char nom[] = "Dupont";
monFichier.write(nom,sizeof(nom));
// sizeof(nom) vaut 7 octets soit 6 caractères + 0x00(fin chaîne)
4.2 Lectures non formatées get() read()
Les fonctions - get(), getline(), read() - permettent de lire des données dans un fichier. Elles sont issues de la
classe istream Voir Gestion des flux avec *stream.
§ char get() : Extrait un caractère et le retourne systématiquement - get(&char) l’affecte à la variable de
référence
§ read( char *s, int n) : Lit une série de caractères( octets), paramètres : Un pointeur sur la zone où les
caractères sont affectés et le nombre de caractère à prélever.
Exemple : get()
char car ;
monFichier.get(car);
// Lit une caractère dans monFichier et l’affecte à car
Exemple : read()
float cote ;
monFichier.read(&cote, sizeof(cote));
// Lit un entier dans monFichier et l’affecte à cote
4.3 Se déplacer dans le flux de données tell(p/g), seek(p/g)
La position est définie par le type streampos dans <ios> et correspond à la position d’un octet dans le flot de
données. Trois constantes de positionnement dans le flux de données sont définies :
§ beg Début du flux (0) end Fin du flux
cur Position courante dans le flux
Les fonctions pour se déplacer dans un flux fichier sont :
§ tellg et seekg - g comme get() réservé au flux fichier en lecture
§ tellp et seekp - p comme put() réservé au flux fichier en écriture
Ces fonctions permettent de lire et de fixer une nouvelle valeur à la position dans le flux de données fichier
courant.
§ streampos tellp() Retourne la position courante dans le flot de données de sortie.
La première position est 0.
§ seekp(streampos position n) Se positionner dans le flot de données de sortie à n octets par
rapport au début du flux. seekp(streamoff n, seek_dir dir) Se positionne à n octet(s) par
rapport à dir ( au début du flot : dir = beg , à la position courante : dir = cur à la fin du flot : dir = end (n
peut être négatif)
Les fonctions tellg() et seekg() sont similaires
Exemple 43-1 : Relire la dernière donnée écrite
float cote=10.1;
float coteLu=0;
David Saint-Mellion
page 4/10
Langage C++
Fichiers et flux de données
21/11/02
fstream fMesure;
// Instance fichier en lecture
// Ouvre le fichier en R/W et positionnement à la fin pour ajout
fMesure.open("mesure.dat",ios::in|ios::out|ios::ate);
fMesure<<cote<<endl;
// Écrit la donnée
fMesure.seekg(-(sizeof(cote)+sizeof('endl')),ios::end); // Se replace
fMesure>>coteLu;
// Relit les données
cout<<"DONNES du flux fichier : "<<coteLu<<endl;
Exemple 43-2 : Taille du fichier
ifstream fMesure ;
streampos positionCourante;
// Instance fichier en lecture
// Variable de position
fMesure.open("mesure.dat");
// Ouvre le fichier
streampos positionCourante = monFichier.tellg(); //Mémorise la position début
fMesure.seekg(0, ios::end);
// Se positionne à la fin
cout<<"Taille du fichier : "<< fMesure.tellg()<<" octet(s)<< endl;
fMesure.seekg(positionCourante, ios::beg); // Reprend la position début
Exemple 43-3 : Relire une série de données dans un flux fichier après écriture
float cote1=111.1;
float cote2=222.2;
float coteLu=0;
fstream fMesure;
// Instance fichier en lecture
streampos OldPosition;
// Variable de position
// Ouvre le fichier en R/W et positionnement à la fin pour ajout
fMesure.open("mesure.dat",ios::in|ios::out|ios::ate);
OldPosition=fMesure.tellp();
// Mémorise la position
fMesure<<cote1 <<endl<<cote2<<endl;
// Écrit les données
// Replace le pointeur de flux à l'ancienne position
fMesure.seekg(OldPosition,ios::beg);
// Reprend l’ancienne position
// Relit les données tq pas EOF voir $542
while(fMesure>>coteLu)
cout<<"DONNES du flux fichier : "<<coteLu<<endl;
fMesure.close();
Voir exemples 64 et 65
5 GERER L’ETAT DU FLUX
L’état du flux de données est indiqué par des drapeaux : (Voir Gérer des flux avec *stream)
ios: :eofbit Indique la fin de fichier
ios: :goodbit Indique l’état normal du flux, lorsqu’il ne s’est produit aucune erreur
ios: :badbit Indique qu’une opération a échoué. N’interdit pas la poursuite des opérations - warning
ios: :failbit Indique qu’une erreur logique s’est produite lors d’une opération de lecture.
ios: :harfail Indique qu’une erreur grave s’est produite. Exemple défaillance matériel : secteur
défectueux d’un disque, coupure réseau
5.1 Les fonctions good(), eof(), fail(), bad() et clear()
Ces fonctions sont des assesseurs des indicateurs des bits d’état du flux. Elles renvoient un booléen
La fonction clear() permet de repositionner ces indicateurs.
Exemple 51 : Evolution des bits indicateurs d’état du flux
#include <fstream>
#include <iostream>
using namespace std;
int main(void) {
float cote=0;
fstream fichierPiece ;
fichierPiece.open("mesure.dat");
//Etat 1
David Saint-Mellion
page 5/10
// Etat 1
Langage C++
Fichiers et flux de données
while(fichierPiece>>cote){
cout<<"Cote
"<<cote<<endl;
}
//Etat 2
21/11/02
// Etat 2
fichierPiece.clear();
//Etat 3
return 0; // Le destructeur ferme le fichier
}
§
§
§
§
// Etat 3
// Etat 1 A l’issue de l’ouverture du fichier, le flux est dans son état normal :
ios::goodbit=1, ios::eofbit=0, ios::badbit=0 , ios::failbit=0
// Etat 2 A l’issue du parcourt, la fin de fichier est atteinte - eof valide, le flux n’est plus dans un état normal :
ios::goodbit=0, ios::eofbit=1, ios::badbit=0 , ios::failbit=1
// Etat 3 clear() repositionne les indicateurs d’état
ios::goodbit=1, ios::eofbit=0, ios::badbit=0 , ios::failbit=0,
// Etat 1 Lors de la tentative d’ouverture d’un fichier inexistant, le bit
fail est activé. En conséquence, good passe à ‘0’ et indique que le flux
n’est pas dans un état normal .
ios::goodbit =0, ios::eofbit=0, ios::badbit=0 , ios::failbit=1
Ouverture d’un fichier inexistant
5.2 Détecter la fin de fichier lors d’une opération de lecture avec >>
L’opérateur d’extraction >> renvoie la valeur la valeur ’0’ sur l’instance de la classe lorsqu’il y a une erreur de
lecture ou qu’il rencontre la fin de fichier - fichierPiece>>cote retourne alors ‘0’. La structure while exécute
la boucle tant que EOF n’est pas trouvé
while(fichierPiece>>cote){
cout<<"Cote "<<cote<<endl;
}
Exemple 52 : Lire et afficher toutes les données d’un fichier
float cote=0 ;
ifstream fMesure;
//Crée un objet fichier en lecture
fMesure.open("mesure.dat");
//Ouvre le fichier
fMesure >>cote;
// Lit le fichier tq != EOF
while(fMesure>>cote) cout<<cote<<endl;
Voir aussi : Exemples 532 et $6
5.3 Gérer les erreurs d’ouverture de fichier
Pour gérer l’échec d’ouverture du fichier on utilise les assesseurs fail() ou gool() - fail() renvoie la valeur true
(gool() - false), s’il y une erreur – Voir Gestion des flux avec *stream).
Exemple : Gérer les erreurs d’ouverture de fichier
#define ERREUR_OUVERTURE
true
if (fichierPiece.fail()==ERREUR_OUVERTURE){
cerr<<"Erreur d'ouverture de NOM_FICHIER "<<endl;
return 1;
}
Voir $6 exemples 63, 64 et 65
6 EXEMPLE TRAITEMENT DU FICHIER PIECE
Liste de Série :
Série = Date+ Nombre de pièces+ Cotes :
Date = année+mois+jour+heure+minutes :
David Saint-Mellion
0 à 20 Série, séparateur des éléments retour chariot ‘\n’
séparateur le retour chariot ‘\n’
alphanumérique, séparateur le point « . »
Ex : 2002.09.29.10.48
page 6/10
Langage C++
Nombre de pièces :
Cotes :
Fichiers et flux de données
21/11/02
entier, valeurs comprises entre 1 et 100
tableau de 1 à 100 réels, séparateur l’espace « »
Ex : 102.56 102 101.09 102.5
6.1 Structure de données
Exemple 61 : Définition de la structure de données Piece
// s_piece.h Déclaration de la structure Pièce et des fonctions
#include <iostream>
#include <string>
using namespace std;
struct Piece {
string serie ;
int nbrePieces;
float cote[100];
};
// Surcharge de l’opérateur >> pour Piece
istream &operator>> (istream &fluxE, Piece &p);
// Surcharge de l’opérateur << pour Piece
ostream &operator<< (ostream &fluxS, Piece &p);
void afficher(Piece &p);
// s_piece.cpp Définition du corps des fonctions
#include "struct_piece.h"
// Surcharge de l'opérateur>>
istream &operator>> (istream &fluxI, Piece &p) {
fluxI>>p.serie;
fluxI>>p.nbrePieces;
for (int i=0; i<p.nbrePieces; i++)
fluxI>>p.cote[i];
return fluxI;
}
// Surcharge de l'opérateur<<
ostream &operator<< (ostream &fluxS, Piece &p) {
fluxS<<p.serie<<endl;
fluxS<<p.nbrePieces<<endl;
for (int i=0; i<p.nbrePieces; i++)
fluxS<<p.cote[i]<<' ';
fluxS<<endl;
return fluxS;
}
void afficher(Piece &p) {
void afficher(Piece &p) {
cout<<p.serie<< " Nombre de pieces : "<<p.nbrePieces<<endl;
cout<<"
Cotes : ";
for (int i=0; i<p.nbrePieces; i++)
cout << p.cote[i] << ' ';
cout<<endl;
}
// Saisir la données d'une série de pièces
void saisir(Piece &p) {
int i=0;
float saisie;
// Saisir les données de la série
cout<<"Saisissez la serie an.mois.jour.heure.minute"<<endl;
cin>>p.serie ;
cout<<"Saisissez la cote, puis faire ENTR"<<endl;
while (cin>>saisie){
p.cote[i]=saisie;
i++;
David Saint-Mellion
page 7/10
Langage C++
Fichiers et flux de données
21/11/02
cout<<"Saisissez la cote, puis faire ENTR"<<endl;
cout<<"Ou Terminez la saisie par CRTL 'Z' "<<endl;
// CRTL 'Z' - Fin de fichier sur un PC
}
p.nbrePieces=i; // Renseigne nbrePieces
}
// Le passage des paramètres de la structure est réalisé par Référence
6.2 Exemples de programmes
Exemple 62 : Ajouter une série de pièces au le fichier Pièce
#include <iostream>
#include <fstream>
using namespace std;
#include "s_piece.h"
#define NOM_FICHIER "piece.dat"
int main(void) {
Piece serie;
ofstream fichierPiece; // Fichier en écriture
// Ouverture du fichier en mode Ajout et positionnement à la fin
fichierPiece.open( NOM_FICHIER,ios::app);
saisir(serie);
fichierPiece<<serie ;
return 0; // Le destructeur ferme et enregistre le fichier
}
Exemple 63 : Lire et Afficher les données des séries de pièces
// Lit le fichier Pièces et affichage des données de chaque série
// Gère les erreurs d’ouverture de fichier
#include <fstream>
#include <iostream>
using namespace std;
#include "s_piece.h"
#define NOM_FICHIER
#define ERREUR_OUVERTURE
"piece.dat"
true
int main(void) {
Piece serie;
int nbreSeries=0;
ifstream fichierPiece; // Fichier en lecture
// Ouvre le fichier et gère l’erreur d’ouverture
fichierPiece.open(NOM_FICHIER);
if (fichierPiece.fail()==ERREUR_OUVERTURE){
cerr<<"Erreur d'ouverture de NOM_FICHIER "<<endl<<endl;
return 1;
}
// Lit une série et l'affiche
while(fichierPiece>>serie){
nbreSeries++;
cout<<"SERIE "<<nbreSeries<<endl;
afficher(serie);
cout<<endl;
}
return 0; // Le destructeur ferme le fichier
}
Exemple 64 : Supprimer une série de pièces du fichier Pièce
// Les séries sont copiées dans un fichier temporaire sauf la série à supprimer
// Puis le fichier temporaire sont copiées dans le fichier Pièce
David Saint-Mellion
page 8/10
Langage C++
Fichiers et flux de données
21/11/02
#include <fstream>
#include <iostream>
using namespace std;
#include "s_piece.h"
#define NOM_FICHIER
#define FICHIER_TMP
#define ERREUR_OUVERTURE
"piece.dat"
"piece.tmp"
false
int main(void) {
Piece serie;
int numero=4;
// Numéro de la série à supprimer
int index=1;
ifstream fichierPieceE;
// Fichier Pièce en lecture
ofstream fichierPieceS;
// Fichier Pièce en écriture
fstream fichierTmp;
// Fichier Temporaire en R/W
streampos debutTmp;
// Variable de position flux
// Ouvre le fichier Pièce en lecture
fichierPieceE.open(NOM_FICHIER);
if (fichierPieceE.good==ERREUR_OUVERTURE){
cerr<<"Erreur d'ouverture de NOM_FICHIER "<<endl<<endl;
return 1;
}
// Ouvre le fichier Temporaire et détruit son contenu
fichierTmp.open(FICHIER_TMP,ios::in|ios::out|ios::trunc);
debutTmp=fichierTmp.tellg();
// Mémorise la position début
// Copie les séries dans fichierTmp sauf celle à supprimer
while(fichierPieceE>>serie){
if(index!=numero){
fichierTmp<<serie;
}
index++;
}
fichierPieceE.close();
// Ferme le fichier Pièce
// Ouvre fichierPiece en lecture en détruisant son contenu
fichierPieceS.open(NOM_FICHIER);
fichierTmp.seekp(debutTmp,ios::beg);
// Se repositionne au début
// Copie les séries de fichierTmp à fichierPiece
while(fichierTmp>>serie)
fichierPieceS<<serie;
return 0; // Les destructeurs ferment les fichiers
}
Exemple 65 : Constituer le fichier Série en se déplaçant dans le fichier Pièce
// Recherche la taille du fichier Pièces, le nombre de séries
// Renseigne le fichier Série avec : la taille du fichier Pièce, le nombre de
// séries, le nombre total de pièces et le nombre de pièces dans chaque série
#include <fstream>
#include <iostream>
using namespace std;
#include "s_piece.h"
#define NOM_FICHIER
#define FICHIER_TMP
#define ERREUR_OUVERTURE
"piece.dat"
"piece.tmp"
true
int main(void){
Piece serie;
int nbreSeries=0;
int totalPieces=0;
int tailleFichier=0;
David Saint-Mellion
page 9/10
Langage C++
Fichiers et flux de données
21/11/02
streampos debutFichierPiece;
// Position début fichier Pièce
streampos positionTotalPieces;
// Position de nbreSeries
streampos positionNbreSeries;
// Position de totalPieces
ifstream fichierPiece;
// Fichier en lecture
ofstream fichierSerie;
// Fichier en écriture
// Ouvre le fichier Pièce en lecture
fichierPiece.open(FICHIER_PIECE);
if (fichierPiece.fail()==ERREUR_OUVERTURE){
cerr<<"Erreur d'ouverture de NOM_FICHIER "<<endl;
return 1;
}
// Ouvre le fichier Série avec destruction du contenu
fichierSerie.open(FICHIER_SERIE,ios::trunc);
// Détermine la Taille du fichier Pièce, écrit la valeur dans fichier Série
debutFichierPiece=fichierPiece.tellg(); // Mémorise la position début
fichierPiece.seekg(0, ios::end);
// Se positionne à la fin
tailleFichier=fichierPiece.tellg();
fichierSerie<<tailleFichier<<endl;
fichierPiece.seekg(debutFichierPiece, ios::beg);// Se repositionne au début
// Réserve l'emplacement pour nbreSeries
positionNbreSeries=fichierSerie.tellp(); // Mémorise la position nbreSeries
fichierSerie<<nbreSeries<<endl;
// Réserve l'emplacement nbreSeries
// Réserve l'emplacement pour totalPiece
positionTotalPieces=fichierSerie.tellp(); // Mémorise la position totalPieces
fichierSerie<<totalPieces<<endl;
// Réserve l'emplacement
// Lit et écrit le nombre de pieces dans une série
while(fichierPiece>>serie){
fichierSerie<<serie.nbrePieces<<' ';
totalPieces += serie.nbrePieces;
nbreSeries++;
}
// Ecrit totalPieces dans le fichier Série
fichierSerie.seekp(positionNbreSeries, ios::beg); // Position sur nbreSerie
fichierSerie<<nbreSeries;
// Renseigne nbreSeries
fichierSerie.seekp(positionTotalPieces, ios::beg); // Position totalPieces
fichierSerie<<totalPieces;
// Renseigne totalPieces
return 0; // Les destructeurs ferment les fichiers
}
7 TABLE DES EXEMPLES DE CODE
Exemples : Ouverture de fichiers open()............................................................................................................ 2
Exemple 31 : Lecture formatée avec l’opérateur d’extraction >> ........................................................................ 3
Exemple 32 : Ecriture formatée avec l’opérateur d’injection << .......................................................................... 3
Exemple : put().................................................................................................................................................. 4
Exemples : write() ............................................................................................................................................. 4
Exemple : get().................................................................................................................................................. 4
Exemple : read() ............................................................................................................................................... 4
Exemple 43-1 : Relire la dernière donnée écrite ................................................................................................ 4
Exemple 43-2 : Taille du fichier ......................................................................................................................... 5
Exemple 43-3 : Relire une série de données dans un flux fichier après écriture ................................................. 5
Exemple 51 : Evolution des bits indicateurs d’état du flux .................................................................................. 5
Exemple 52 : Lire et afficher toutes les données d’un fichier .............................................................................. 6
Exemple : Gérer les erreurs d’ouverture de fichier ............................................................................................. 6
Exemple 61 : Définition de la structure de données Piece.................................................................................. 7
Exemple 62 : Ajouter une série de pièces au le fichier Pièce............................................................................. 8
Exemple 63 : Lire et Afficher les données des séries de pièces ......................................................................... 8
Exemple 64 : Supprimer une série de pièces du fichier Pièce ............................................................................ 8
Exemple 65 : Constituer le fichier Série en se déplaçant dans le fichier Pièce.................................................... 9
David Saint-Mellion
page 10/10