Upload
others
View
2
Download
0
Embed Size (px)
Citation preview
Module “Info4”
Filières SMI-SMA
Semestre 4
A. DARGHAM
Département des Mathématiques et Informatique
Chapitre 2 :
Les fichiers
2
Sommaire Sommaire
� Notion de fichier
� Types de fichiers
� Pointeur de fichier� Ouverture et fermeture d’un fichier
� E/S formatées avec les fichiers
� E/S par caractères
� E/S par lignes
3
Types de fichiersTypes de fichiers
� Notion de fichier◦ Un fichier désigne une collection d’informations stockées dans un support physique (disque dur, disquette, CD, DVD, Bande magnétique, clé USB, …).
◦ Un fichier est caractérisé par son nom, sa taille (en octets), son répertoire où il est enregistré, son type, …etc.
4
Types de fichiersTypes de fichiers
� Fichiers Textes◦ Chaque octet représente un caractère.
◦ Le contenu peut être scindé en plusieurs lignes.
◦ Le fichier peut contenir un marqueur de « fin de fichier ».
5
Types de fichiersTypes de fichiers
� Exemples de Fichiers Textes◦ Fichier contenant le code source d’un programme « C ».
◦ Fichier « HTML », « CSS », « JavaScript ».
◦ Fichier XML.
◦ Tout fichier édité par un éditeur de texte (bloc-note).
6
Types de fichiersTypes de fichiers
� Fichiers binaires◦ Un octet ne représente pas nécessairement un caractère.
◦ Chaque groupe d’octets a une signification précise (un entier, un réel, une image, …).
◦ Le contenu n’est pas divisé en lignes.
◦ Pas de marqueur de « fin de fichier ».
7
Types de fichiersTypes de fichiers
� Exemples de fichiers binaires◦ Fichier contenant le code machine d’un programme « C ».
◦ Fichier stockant une image.
◦ Fichier stockant une vidéo.
8
Types de fichiersTypes de fichiers
� Exemple explicatif◦ Soit l’information « 32767 » à mettre dans un fichier.
◦ Un fichier texte va représenter chaque caractère par son code (ASCII, par exemple) et le stocker dans un octet.
9
Types de fichiersTypes de fichiers
� Exemple explicatif◦ Un fichier binaire va représenter cette information en utilisant un codage approprié(Complément à 2, par exemple) et le stocker en utilisant un certain nombre d’octets.
10
Pointeur de fichierPointeur de fichier
� Structure FILE◦ Structure spéciale qui décrit un fichier.
◦ Elle est définie dans .
� Pointeur de fichier◦ C’est un pointeur vers une structure « FILE ».
� Déclaration ◦ FILE * fp;
� Rôle ◦ La manipulation d’un fichier s’effectue toujours à travers un pointeur de fichier.
11
Ouverture et fermeture dOuverture et fermeture d’’un fichierun fichier
� Ouverture d’un fichier◦ FILE * fopen(const char * nom, const char * mode);
� Arguments de « fopen »◦ « nom » : est le nom du fichier.
◦ Le nom peut être :� soit relatif : on ne donne que le nom du fichier avec son extension (exemple, « data.txt »).
� soit absolu : on donne le nom complet (chemin + nom final). Exemple : « C:\Magazin\data.txt »
12
Ouverture et fermeture dOuverture et fermeture d’’un fichierun fichier
� Arguments de « fopen »◦ « mode » : est le mode d’ouverture du fichier.
◦ La valeur du mode peut être :� "r" : accès en mode lecture. Produit une erreur si le fichier n’existe pas.
� "w" : accès en mode écriture. Initialise le fichier si ce dernier existe déjà, sinon il le crée.
� "a" : accès en mode écriture à la fin (ajout). Conserve le fichier si ce dernier existe déjà, sinon il le crée.
13
Ouverture et fermeture dOuverture et fermeture d’’un fichierun fichier
� Arguments de « fopen »◦ « mode » : est le mode d’ouverture du fichier.
◦ La valeur du mode peut être :� "r+" : accès en mode lecture/écriture. Produit une erreur si le fichier n’existe pas.
� "w+" : accès en mode lecture/écriture. Initialise le fichier si ce dernier existe déjà, sinon il le crée.
� "a+" : accès en mode lecture/écriture (à la fin). Conserve le fichier si ce dernier existe déjà, sinon il le crée.
14
Ouverture et fermeture dOuverture et fermeture d’’un fichierun fichier
� Arguments de « fopen »◦ Dans le « mode », on peut également préciser le type de fichier à ouvrir, en ajoutant à la fin du mode l’un des deux caractères : � "t" : pour un fichier texte. Cela est pris par défaut.
� "b" : pour un fichier binaire.
◦ Exemple :� "ab+" : accès en mode lecture/écriture à la fin avec à un fichier binaire.
15
Ouverture et fermeture dOuverture et fermeture d’’un fichierun fichier
� Valeur retournée par « fopen »◦ Il y a deux cas possibles :
� Il y a un problème d’ouverture de fichier : dans ce cas, la fonction « fopen » renvoie le pointeur NULL.
� L’opération a terminée avec succès : la fonction «fopen » retourne un pointeur vers le fichier ouvert.
16
Ouverture et fermeture dOuverture et fermeture d’’un fichierun fichier
� Fermeture d’un fichier ◦ int fclose(FILE * fp);
◦ La fonction « fclose » ferme le fichier et termine la communication entre le fichier et le programme.
◦ L’argument « fp » doit être un pointeur sur fichier.
◦ Le pointeur de fichier peut être alloué ànouveau par la fonction « fopen ».
◦ La fonction « fclose » retourne la constante EOF si une erreur s’est produite, 0 sinon.
17
Ouverture et fermeture dOuverture et fermeture d’’un fichierun fichier
� Structure générale d’un programme manipulant les fichiers . . . . . . . . . .
FILE * fp;
. . . . . . . . . .
fp = fopen(. . ., "r");
if(fp)
{ // traitements du fichier }
else
{ // message d’erreur }
. . . . . . . . . .
fclose(fp);
. . . . . . . . . .18
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Fonction « fprintf »◦ int fprintf(FILE * fp, cosnt char * format, …);
◦ La fonction « fprintf » écrit une donnée dans un fichier.
◦ L’argument « fp » est un pointeur sur fichier.
◦ Le format d’écriture est précisé dans le deuxième argument « format ».
◦ La liste des variables est donnée à partir du deuxième argument (séparées par des « , »).
19
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Fonction « fscanf »◦ int fscanf(FILE * fp, cosnt char * format, …);
◦ La fonction « fscanf » lit une donnée à partir d’un fichier.
◦ L’argument « fp » est un pointeur sur fichier.
◦ Le format de lecture est précisé dans le deuxième argument « format ».
◦ La liste des variables est donnée à partir du deuxième argument (séparées par des « , »).
20
E/S formatE/S formatéées avec les fichierses avec les fichiers
21
FichierVariable
fscanf
fprintf
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Exercice corrigé1 ◦ Écrivons un programme qui lit 10 entiers et les stocke dans un fichier texte.
◦ Les valeurs lues seront séparées par des caractères de retour à la ligne.
22
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programme#include
main()
{
FILE * fp;
int i, n;
fp = fopen("fichier.txt", "w");
if(fp)
{
for(i = 0; i < 10; i++)
{ 23
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmeprintf("un entier : ");
scanf("%d", &n);
fprintf(fp, "%d\n", n);
} // end for
fclose(fp);
} // end if
else
printf("Erreur d'ouverture de fichier\n");
system("pause");
}24
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : l’exécution du programme
25
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : le fichier crée
26
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Exercice corrigé 2 ◦ Écrivons un programme qui ouvre le fichier «fichier.txt » crée par le programme précédent (exercice 1) et qui range les 10 entiers enregistrés dans un tableau.
◦ Ensuite, le programme affiche les entiers stockés dans le tableau.
27
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programme#include
main()
{
FILE * fp;
int i;
int t[10];
fp = fopen("fichier.txt", "r");
if(fp)
{
for(i = 0; i < 10; i++)
{ 28
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmefscanf(fp, "%d\n", &t[i]);
} // end for
fclose(fp);
for(i = 0; i < 10; i++)
printf("%d\n", t[i]);
} // end if
else
printf("Erreur d'ouverture de fichier\n");
system("pause");
}29
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : l’exécution du programme
30
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Fonction « feof »◦ int fscanf(FILE * fp);
◦ La fonction « feof » retourne une valeur entière non nulle si la tête de lecture est en fin de fichier.
◦ Pour tester si la fin de fichier n’est pas encore atteint, il faut donc écrire
if(!feof(fp))
31
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Exercice corrigé 3 ◦ Dans un fichier texte « etudiants.txt », est enregistré les données sur des étudiants :� CNE
� Nom
� Moyenne
◦ Écrivons les fonctions suivantes : � Une fonction qui cherche un étudiant par son CNE.
� Une fonction qui donne la plus petite moyenne.
32
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Fichier « etudiants.txt »
33
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : l’exécution du programme
34
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : l’exécution du programme
35
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programme#include
#include
typedef struct etudiant
{
char cne[12];
char nom[20];
float moyenne;
} etudiant;
const etudiant fictif = {"", "", 0.0};
// à retourner en cas d’un cne inexistant
int estFictif(etudiant); // teste si étudiant est fictif 36
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmeetudiant obtenirEtudCNE(const char * cne)
{
FILE * fp;
etudiant e;
fp = fopen("etudiants.txt", "r");
if(fp)
{
do {
fscanf(fp, "%s %s %f\n", e.cne, e.nom, &e.moyenne);
if(strcmp(e.cne, cne) == 0)37
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmereturn e;
}while(!feof(fp));
}
fclose(fp);
return fictif;
}
float obtenirPetiteMoy()
{
FILE * fp;
float m = 21.0; 38
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmechar cne[12] , nom[20];
float moy;
fp = fopen("etudiants.txt", "r");
if(fp) {
do {
fscanf(fp, "%s %s %f\n", cne, nom, &moy);
if(moy < m)
m = moy;
}while(!feof(fp)); }
fclose(fp);
return moy; } 39
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmemain()
{
etudiant e;
char cne[12];
float moy;
printf("Donnez le CNE : ");
gets(cne);
e = obtenirEtudCNE(cne);
if(estFictif(e))
printf("Etudiant inexistent!!!\n");40
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmeelse {
printf("Etudiant trouve :\n");
printf("\tCNE %s\n", e.cne);
printf("\tNom %s\n", e.nom);
printf("\tMoyenne %.2f\n", e.moyenne);
}
moy = obtenirPetiteMoy();
printf("Plus petite moyenne : %.2f\n", moy);
system("pause");
}41
E/S formatE/S formatéées avec les fichierses avec les fichiers
� Solution : programmeint estFictif(etudiant e)
{
return strlen(e.cne) == 0
&&
strlen(e.nom) == 0
&&
e.moyenne == 0.0;
}
42
E/S par caractE/S par caractèèresres
� Fonction « fgetc »◦ int fgetc(FILE * fp);
◦ La fonction « fgetc » lit un caractère à partir d’un fichier. Elle retourne le caractère lu.
◦ Après la lecture du caractère courant, la fonction positionne la tête de lecture sur le caractère suivant.
◦ Lorsqu’on arrive au fin de fichier, la fonction retourne un caractère spécial « EOF » (EndOf File).
43
E/S par caractE/S par caractèèresres
� Fonction « fgetc »◦ Parcourir un fichier caractère par caractère :
car = fgetc(fp);
while(car != EOF)
{
// traitement du caractère courant
car = fgetc(fp); // prendre la caractère suivant
}
44
E/S par caractE/S par caractèèresres
� Exercice corrigé 4 : ◦ Écrivons un programme qui lit un fichier texte caractère par caractère, en comptant :� Le nombre d’espaces.
� Le nombre de tabulations.
� Le nombre de lignes.
45
E/S par caractE/S par caractèèresres
46
E/S par caractE/S par caractèèresres
47
E/S par caractE/S par caractèèresres
� Programme : #include
main()
{
FILE * fp;
char car;
int nl, ne, nt;
ne = nl = nt = 0;
fp = fopen("input.txt", "r");
car = fgetc(fp); 48
E/S par caractE/S par caractèèresres
� Programme : while(car != EOF) {
switch(car) {
case ' ' : ne++; break;
case '\t' : nt++; break;
case '\n' : nl++; break; }
car = fgetc(fp); }
printf("Nombre d'espaces : %d\n", ne);
printf("Nombre de tabulations : %d\n", nt);
printf("Nombre de lignes : %d\n", nl);
system("pause"); }49
E/S par caractE/S par caractèèresres
� Fonction « fputc »◦ int fputc(int car, FILE * fp);
◦ La fonction « fputc » écrit un caractère dans un fichier. Elle retourne le caractère écrit.
◦ La fonction retourne « EOF » si une erreur se produit.
◦ La valeur de retour est en fait un « int » et non pas un char.
◦ La raison est de permettre l’envoi de « EOF »qui est un entier.
50
E/S par caractE/S par caractèèresres
� Exercice corrigé 5 : ◦ Écrivons un programme qui ouvre un fichier texte, puis écrit le message « bonjour !».
51
E/S par caractE/S par caractèèresres
� Solution : #include
main()
{
FILE * fp;
char msg[] = "Bonjour !";
int i = 0;
fp = fopen("test.txt", "w");
if(fp)
{
while(msg[i])
{ 52
E/S par caractE/S par caractèèresres
� Solution : fputc(msg[i], fp);
i++;
}
}
else
printf("Erreur d’ouverture de fichier\n");
fclose(fp);
system("pause");
}
53
E/S par caractE/S par caractèèresres
54
E/S par lignesE/S par lignes
� Fonction « fgets »◦ char * fgets(char* tampon, int nb, FILE* fp);
◦ La fonction « fgets » lit une chaîne de caractères à partir d’un fichier.
◦ La fonction lit au plus un nombre de caractères spécifié dans le paramètre « nb ».
◦ Elle s’arrête au premier caractère '\n' rencontré ou lors de la détection d’une fin de fichier.
◦ Le caractère '\0' est ajouté à la fin de la chaîne lue.
55
E/S par caractE/S par caractèèresres
� Exercice corrigé 6 : ◦ Écrivons un programme qui lit un fichier texte ligne par ligne en les affichant sur la sortie standard (l’écran).
56
E/S par caractE/S par caractèèresres
� Fichier à lire :
57
E/S par caractE/S par caractèèresres
� Solution : #include
main()
{
FILE * fp;
char ligne[100];
fp = fopen("test.txt", "r");
if(fp)
{
while(!feof(fp))
{
58
E/S par caractE/S par caractèèresres
� Solution : fgets(ligne, sizeof(ligne), fp);
printf("%s\n", ligne);
}
}
else
printf("Erreur d’ouverture de fichier\n");
fclose(fp);
system("pause");
}
59
E/S par caractE/S par caractèèresres
� Exécution du programme :
60
E/S par lignesE/S par lignes
� Fonction « fputs »◦ int fputs(const char * ch, FILE* fp);
◦ La fonction « fgets » écrit une chaîne de caractères dans un fichier.
◦ Elle retourne EOF en cas d’erreur.
◦ La fonction « fgets » n’ajoute pas le caractère '\n' (ni '\0') dans le fichier.
61
E/S par caractE/S par caractèèresres
� Exercice corrigé 7 : ◦ Écrivons un programme qui écrit des données dans un fichier texte ligne par ligne.
62
E/S par caractE/S par caractèèresres
� Solution : #include
main()
{
FILE * fp;
char ligne[100];
int i;
fp = fopen("test.txt", "r");
if(fp)
{
for(i = 0; i < 3; i++)
{ 63
E/S par caractE/S par caractèèresres
� Solution : gets(ligne);
strcat(ligne, "\n");
fputs(ligne, fp);
}
}
else
printf("Erreur d’ouverture de fichier\n");
fclose(fp);
system("pause");
}
64
E/S par lignesE/S par lignes
� Exécution
65
E/S par lignesE/S par lignes
� Fichier résultat
66
RRéésumsuméé ((àà retenir)retenir)
67
fclose(fp)Fermeture
fprintf, fputc, fputsOpérations d’écriture
fscnaf, fgetc, fgetsOpérations de lecture
fp = foepn(nom, "a")Ouverture en ajout
fp = foepn(nom, "w")Ouverture en écriture
fp = fopen(nom, "r") Ouverture en lecture
FILE * fp;Déclaration