COURS : COMPLEMENT ALGORITHME

Chapitre 1 : Les fichiers

Pourquoi les fichiers sont-ils
nécessaires ?

Lorsqu'un programme se termine, l'ensemble des données

est perdu. Le stockage dans un fichier permet de
conserver vos données même si le programme se
termine.
Si vous devez saisir un grand nombre de données, il vous
faudra beaucoup de temps pour les saisir toutes.
Cependant, si vous disposez d'un fichier contenant toutes
les données, vous pouvez facilement accéder au contenu
du fichier en utilisant quelques commandes en C.
Vous pouvez facilement déplacer vos données d'un
ordinateur à un autre sans les modifier.

3
Types de fichiers

Lorsqu'il s'agit de fichiers, il existe deux types de

fichiers que vous devez connaître :

1-Les fichiers texte ;

2- Les fichiers binaires.

4
1. Les fichiers texte

Les fichiers texte sont les fichiers .txt normaux. Vous

pouvez facilement créer des fichiers texte à l'aide d'un
éditeur de texte simple tel que le Bloc-notes.
Lorsque vous ouvrez ces fichiers, vous voyez tout le
contenu du fichier sous forme de texte brut. Vous
pouvez facilement modifier ou supprimer le contenu.

Ils demandent un minimum d'efforts de maintenance,

sont facilement lisibles, offrent le moins de sécurité et
occupent un espace de stockage plus important.

5
2. Les fichiers binaires

Les fichiers binaires sont principalement les

fichiers .bin de votre ordinateur.
Au lieu de stocker les données en texte clair, ils les
stockent sous forme binaire (0 et 1).
Ils peuvent contenir une plus grande quantité de
données, ne sont pas lisibles facilement et offrent une
meilleure sécurité que les fichiers texte.

6
Opérations sur les fichiers

En C, vous pouvez effectuer quatre opérations

principales sur des fichiers, qu'ils soient textuels ou
binaires :
1.Création d'un nouveau fichier ;
2.Ouverture d'un fichier existant ;
3.Fermeture d'un fichier ;
4.Lecture et écriture d'informations dans un fichier.

7
Le langage C fournit un certain nombre de fonctions
qui permettent d'effectuer des opérations de base sur
les fichiers. Ces fonctions sont les suivantes,

8
Entrée/sortie de fichiers en C

Un fichier représente une séquence d'octets sur le

disque où un groupe de données connexes est stocké.
Le fichier est créé pour le stockage permanent de
données. Il s'agit d'une structure prête à l'emploi.

En langage C, nous utilisons un pointeur de structure

de type fichier pour déclarer un fichier.

FILE *fp;

9
Ouverture d'un fichier

L'ouverture d'un fichier est effectuée à l'aide de la

fonction fopen() définie dans le fichier d'en-tête
stdio.h.
La syntaxe d'ouverture d'un fichier en E/S
standard est la suivante :

ptr = fopen("fileopen", "mode") ;

Par exemple :
fopen("E:\cprogram\\\Nouveauprogramme.txt", "w") ;

10
Lecture et écriture dans un fichier texte

Pour lire et écrire dans un fichier texte, nous utilisons

les fonctions fprintf() et fscanf().

Il s'agit simplement de la version fichier de printf() et

scanf(). La seule différence est que fprintf() et
fscanf() attendent un pointeur vers la structure FILE.

11
 fputs

Exemple
#include <stdio.h>
main() {
FILE *fp ;
fp = fopen("/tmp/test.txt", "w+") ;
fprintf(fp, "This is testing for fprintf...\n") ;
fputs("Ceci est un test pour fputs...\n", fp) ;
fclose(fp) ;
}

12
Lecture du fichier :

int getc(FILE *fichier);

Lit 1 caractère, mais retourne un entier n;
retourne EOF si erreur ou fin de fichier;
le pointeur avance d'une case.
Exemple:
char c ;
c = (char)getc(fichier) ;

13
char *fgets(char *chaine,int n,FILE
*fichier);

Lit n-1 caractères à partir de la position du pointeur et

les range dans chaine en ajoutant
'\0'.

14
Exemple 1 : Ecriture dans un fichier
texte

#include <stdio.h>
#include <stdlib.h>

int main()
{
int num ;
FILE *fptr ;

// utilisez l'emplacement approprié si vous utilisez MacOS ou Linux

fptr = fopen("C:\\programme.txt", "w") ;

if(fptr == NULL)
{
printf("Erreur !") ;
exit(1) ;
}

printf("Entrez le numéro : ") ;

scanf("%d",&num) ;

fprintf(fptr,"%d",num) ;
fclose(fptr) ;

Retourne 0 ;
}

15
Exemple 2 : Ecriture dans un fichier
texte

#include <stdio.h>
#include <stdlib.h>

int main()
{
int num ;
FILE *fptr ;

// utilisez l'emplacement approprié si vous utilisez MacOS ou Linux

fptr = fopen("C:\\programme.txt", "w") ;

if(fptr == NULL)
{
printf("Erreur !") ;
exit(1) ;
}

printf("Entrez le numéro : ") ;

scanf("%d",&num) ;

fprintf(fptr,"%d",num) ;
fclose(fptr) ;

return 0 ;
}

16
Explications

Ce programme prend un numéro de l'utilisateur et le

stocke dans le fichier program.txt.

Après avoir compilé et exécuté ce programme, vous

pouvez voir un fichier texte program.txt créé dans le
lecteur C de votre ordinateur. Lorsque vous ouvrez le
fichier, vous pouvez voir le nombre entier que vous
avez saisi.

17
Exemple 2: Lecture d'un fichier texte

#include <stdio.h>
#include <stdlib.h>
int main()
{
int num ;
FILE *fptr ;

if ((fptr = fopen("programme.txt", "r")) == NULL)

{
printf("Erreur ! ouverture de fichier");
exit(1);
}

fscanf(fptr, "%d", &num);

printf("Valeur de n=%d", num);

fclose(fptr);
return 0;
}

18
Explication exemple 2

Ce programme lit le nombre entier présent dans le

fichier program.txt et l'imprime à l'écran.

Si vous avez réussi à créer le fichier de l'exemple 1,

l'exécution de ce programme vous permettra d'obtenir
le nombre entier que vous avez entré.
D'autres fonctions comme fgetchar(), fputc() etc.
peuvent être utilisées de manière similaire.

19
Lecture et écriture dans un fichier
binaire

Les fonctions fread() et fwrite() sont utilisées pour

lire et écrire dans un fichier sur le disque
respectivement dans le cas de fichiers binaires.

20
Écriture dans un fichier binaire

Pour écrire dans un fichier binaire, vous devez utiliser

la fonction fwrite(). Ces fonctions prennent quatre
arguments :
1- l'adresse des données à écrire sur le disque
2- la taille des données à écrire sur le disque
3- nombre de ce type de données
4- un pointeur vers le fichier dans lequel vous voulez
écrire.
fwrite(adresseDonnees, tailleDonnees,
nombreDonnees, pointeurDefichier) ;

21
Exemple

#include <stdio.h>

void main()

{char nomfich[21];

int n;

FILE * sortie;

printf("Saisir le nom du fichier à créer :");

scanf("%s", nomfich);

sortie = fopen(nomfich,"w");

do{

printf("saisir un entier:");

scanf("%d", &n);

if(n!=0)

fwrite(&n, sizeof(int),1,sortie);

}while(n!=0);

fclose(sortie);

22
Explication

La ligne FILE * sortie, signifie que sortie est un pointeur sur un

objet de type FILE(fichier).

Dans la ligne sortie = fopen(nomfich,"w");

FILE *fopen(const char *nom , const char *mode), possède

deux arguments :

- nom : nom (ou chemin) externe du fichier à ouvrir

- mode : mode d'ouverture.

23
Mode Description

r Ouverture en lecture seule sur un fichier existant

w Ouverture en écriture seule. Si le fichier existe il est détruit.
a Ouverture pour écriture à la fin du fichier. Création du fichier s'il n'existe pas
r+ Ouverture en lecture ou écriture sur un fichier existant.
w+ Ouverture en lecture ou écriture. Si le fichier existe il est détruit. Création du fichier s'il
n'existe pas.
a+ Ouverture en lecture ou écriture à la fin du fichier. Création du fichier s'il n'existe pas.
rb ouverture d'un fichier binaire en lecture.
Wb ouverture d'un fichier binaire en écriture.
ab ouverture d'un fichier binaire en écriture à la fin.

24
fclose(sortie);

- Fermeture d'un fichier (fclose) :

- Syntaxe :
-int fclose(FILE *stream);
- cette fonction ferme le fichier stream désigné, après avoir vidé le
tampon qui lui est associé.
- Elle retourne 0 si elle réussit, dans le cas contraire elle retourne EOF
(constante de fin de fichier valant -1)

25
Lecture d'un fichier binaire

La fonction fread() prend également 4 rguments,

comme la fonction fwrite() ci-dessus.
fread(adresseDonnees, tailleDonnees,
nombreDonnees, pointeurDefichier) ;

26
Exemple

#include <stdio.h>
void main()
{
char nomfich[21];
int n;
FILE * entree;
printf("Saisir le nom du fichier à lister:");
scanf("%20s", nomfich);
entree = fopen(nomfich,"r");
while(fread(&n, sizeof(int),1,entree) && !feof(entree))
printf("\n %d", n);
fclose(entree);
}

27
Tester la fin de fichier (feof)

int feof(FILE *stream);

Cette fonction retourne une valeur non nulle si la fin de fichier
désigné par stream est atteinte. Elle permet donc de distinguer
une erreur de lecture ou d'écriture d'une fin de fichier.

28
Accès direct

Les fonction fread et fwrite lisent et écrivent

respectivement un
certains nombre d’octets dans un fichier à partir d’une
position courante.
- Cette position étant un pointeur dans le fichier; c’est-
à-dire le
nombre précisant le rang du prochain octet à lire ou à
écrire.
- Après chaque opération, ce pointeur est incrémenté
du nombre
d’octets transféré.

29
Fonction fseek.

Il est possible d’agir directement sur le pointeur de

fichier à l’aide de la fonction fseek.
- Ce qui permet de réaliser la lecture et l’écriture à
l’endroit souhaité, et réaliser ainsi l’accès direct.

30
Si vous avez de nombreux enregistrements dans un fichier
et que vous avez besoin d'accéder à un enregistrement à
une position spécifique, vous devez parcourir en boucle
tous les enregistrements précédents pour obtenir
l'enregistrement.
Cela entraîne une perte importante de mémoire et de
temps de fonctionnement. Un moyen plus facile d'accéder
aux données requises peut être réalisé en utilisant fseek().

Comme son nom l'indique, fseek() cherche le curseur à

l'enregistrement donné dans le fichier.

31
Syntaxe de fseek()

int fseek(FILE *stream, long offset, int

methode);
- fseek positionne le pointeur de fichier du flux stream
pour la prochaine opération de lecture/écriture.
-SEEK_SET (0) : Positionnement à offset octet(s) du
début du fichier.
-SEEK_CUR (1) : Positionnement à la position courante
offset octet(s).
-SEEK_END (2) : Positionnement à la fin du fichier +
offset

32
Explications

Le premier paramètre stream est le pointeur vers le

fichier. Le deuxième paramètre est la position de
l'enregistrement à trouver, et le troisième paramètre
spécifie l'endroit où commence le décalage.

33
 Exemple : fseek()

#include <stdio.h>
#include <stdlib.h>

struct threeNum
{
int n1, n2, n3 ;
};

int main()
{
int n ;
struct threeNum num ;
FILE *fptr ;

si ((fptr = fopen("C:\\programme.bin", "rb")) == NULL){

printf("Erreur ! ouverture de fichier") ;

// Le programme se termine si le pointeur de fichier renvoie NULL.

exit(1) ;
}

34
Exemple : fseek()

// Déplace le curseur à la fin du fichier

fseek(fptr, -sizeof(struct threeNum), SEEK_END) ;

for(n = 1 ; n < 5 ; ++n)

{
fread(&num, sizeof(struct threeNum), 1, fptr) ;
printf("n1 : %d\tn2 : %d\tn3 : %d\n", num.n1, num.n2, num.n3) ;
fseek(fptr, -2*sizeof(struct threeNum), SEEK_CUR) ;
}
fclose(fptr) ;

retourne 0 ;
}

35
Explications

Ce programme va commencer à lire les enregistrements du fichier program.bin dans

l'ordre inverse (du dernier au premier) et les imprimer.

36
Position courante du pointeur de fichier (ftell)

Syntaxe :
- long ftell(FILE *stream);
- Cette fonction retourne la position courante du
pointeur de fichier ou la valeur -1 quand il y a une
erreur.

37
fseek() et ftell

// Programme en C pour démontrer l'utilisation de fseek() et ftell.

#include <stdio.h>

int main()
{
FILE *fp ;
fp = fopen("programme.txt", "r") ;

// Déplacement du pointeur vers la fin

fseek(fp, 0, SEEK_END) ;

// Impression de la position du pointeur

printf("%ld", ftell(fp)) ;

Retourne 0 ;
}

38
 Exemple
#include <stdio.h>
void main()
{
char nomfich[21];
int n; long num;
FILE * entree;
printf("Saisir le nom du fichier à lister:");
scanf("%20s", nomfich);
entree = fopen(nomfich,"r");
do{ printf("donner le numéro de l’entier à rechercher :");
scanf("%ld", &num);
if(num!=0) {fseek(entree, sizeof(int)*(num-1),0);
fread(&n, sizeof(int),1,entree);
printf("\n la valeur est %d", n);}
} while(num!=0);
fclose(entree);
}

39
Suppression d’un fichier

La fonction remove supprime le fichier désigné.

int remove(const char *nom);
-Elle retourne 0 si l'opération a réussi et une valeur non nulle si elle a
échoué.

40
Exemple

#include <stdio.h>

void main() {
char nomfich[21];
printf("Saisir le nom du fichier a effacer: ");
scanf("%20s", nomfich);
if (remove(nomfich) == 0)
printf("Effacement de %s\n", nomfich);
else
printf("Effacement de %s\n non réalisé", nomfich);
}

41
Renommage

La fonction rename modifie le nom d'un fichier. L’ancien nom est

remplacé par nouveau nom. Elle retourne 0 si l'opération a réussi et
une valeur non nulle si elle a échoué.

rename(source, dest)

42
Exemple

#include <stdio.h>

void main() {
char source[21], dest[21];
printf("Saisir le nom du fichier a renommer: ");
scanf("%20s", source);
printf("Saisir le nouveau nom du fichier : ");
scanf("%20s", dest);
if (rename(source, dest) == 0)
printf("Fichier reno mmé");
else
printf("renommage non réalisé");
}

43
 Fonction rewind

Positionnement du pointeur au début du fichier : void rewind(FILE *fichier);

Exemple
// Programme en C pour démontrer l'utilisation de fseek() et ftell.
#include <stdio.h>
int main()
{
FILE *fp ;
fp = fopen("programme.txt", "r") ;
// Déplacement du pointeur vers la fin
fseek(fp, 0, SEEK_END) ;
// Impression de la position du pointeur
printf("Avant %ld\n ", ftell(fp)) ;
rewind(fp);
printf("Apres %ld \n", ftell(fp)) ;
return 0 ;
}
44
Exemple lecture ecriture

#include <stdio.h>
struct student
{
char name[50] ;
int hauteur ;
};
int main(){
struct student stud1[5], stud2[5] ;
FILE *fptr ;
int i ;

fptr = fopen("file.txt", "wb") ;

for(i = 0 ; i < 5 ; ++i)
{
fflush(stdin) ;
printf("Entrez le nom : ") ;
gets(stud1[i].name) ;

printf("Entrez la hauteur : ") ;

scanf("%d", &stud1[i].height) ;
}

fwrite(stud1, sizeof(stud1), 1, fptr) ;

fclose(fptr) ;

fptr = fopen("file.txt", "rb") ;

fread(stud2, sizeof(stud2), 1, fptr) ;
for(i = 0 ; i < 5 ; ++i)
{
printf("Nom : %s\nHeight : %d", stud2[i].name, stud2[i].height) ;
}
fclose(fptr) ;

45
Exercice d ‘application

Exercice: Copier un fichier texte dans un autre:

créer un fichier "programme.txt" sous éditeur.
Tester le programme en vérifiant après exécution
la présence du fichier copié dans le directory.

46
Chapitre 2 : Allocation dynamique
Comme vous le savez, un tableau est une collection d'un
nombre fixe de valeurs. Une fois que la taille d'un tableau
est déclarée, vous ne pouvez pas la modifier.

Parfois, la taille du tableau que vous avez déclaré peut être

insuffisante. Pour résoudre ce problème, vous pouvez allouer
de la mémoire manuellement pendant l'exécution. C'est ce
qu'on appelle l'allocation dynamique de mémoire en
programmation C.

Pour allouer de la mémoire dynamiquement, on utilise les

fonctions de la bibliothèque <stdlib.h> que sont malloc(),
calloc(), realloc() et free().

48
Fonction malloc()

La fonction malloc() réserve un bloc de mémoire du nombre d'octets

spécifié.
Sa syntaxe est

malloc(nombre-octets)

Cette fonction retourne un pointeur de type char * pointant vers un objet

de taille nombre-octets octets. Pour initialiser des pointeurs vers des
objets qui ne sont pas de type char,il faut convertir le type de la sortie de
la fonction malloc à l’aide d’un cast. L’argument nombre-octets est
souvent donné à l’aide de la fonction sizeof() qui renvoie le nombre
d’octets utilisés pour stocker un objet.Ainsi, pour initialiser un pointeur
vers un entier, on écrit :

49
Fonction malloc() : Cas géneral

• Soit T le nom d'un type prédéfini (int, char, etc ...) ou inventé par l'usager (comme Etudiant,
Employe, Personne, etc ...).

• Avec la déclaration : T * p ;

– p est une variable de type pointeur qui pointe vers un élément de type T.

– *p est une variable de type T.

• Allocation dynamique se fait par l'affectation suivante :

– p = (T *) malloc (sizeof(T));

– sizeof(T) donne la taille de T en nombre d'octets (de bytes).

• On demande l'espace de mémoire pour stocker *p et on dépose l'adresse de *p dans p: on dit aussi
que P "pointe vers" *p

50
Exemple

#include <stdlib.h>

int *p;

p = (int*)malloc(sizeof(int));

51
Exemple1 avec une structure

typedef struct

{ ......

} Etudiant ;

Etudiant * p ;

p = (Etudiant *) malloc ( sizeof(Etudiant)) ;

• On demande d'allouer le nombre d'octets nécessaires pour mémoriser *p qui est de type Etudiant.

• La valeur de p est l'adresse de *p en zone dynamique.

Déclarations d'un tableau de 2000 pointeurs, chacun pointe vers le type Employe.

52
Exemple2 avec une structure

Déclarations d'un tableau de 2000 pointeurs, chacun pointe vers le type Employe.

#define MAX_EMPL 2000

#define LONG_NP 30

typedef struct

char nomPre[LONG_NP +1] ;

int numero ;

float taille, salHebdo ;

} Employe ;

Employe *p[MAX_EMPL] ;

53
Exemple2 avec une structure suite

• Bloc d'instructions pour démontrer la faisabilité de l'allocation dynamique

void main()

int k , nbOctets = sizeof(Employe);

for (k = 0 ; k < MAX_EMPL ; k++)

p[k] = (Employe *) malloc(nbOctets);

......}

OU

for (k = 0 ; k < MAX_EMPL ; k++)

p[k] = (Employe *) malloc(sizeof(Employe));

......

54
Fonction calloc()

La fonction calloc a le même rôle que la fonction

malloc mais elle initialise en plus l’objet pointé *p
à zéro. Sa syntaxe est
calloc(nb-objets,taille-objets)
Ainsi, si p est de type int*, l’instruction
p = (int*)calloc(N,sizeof(int));
est strictement équivalente à p = (int*)malloc(N *
sizeof(int));
for (i = 0; i < N; i++)
*(p + i) = 0;

55
Fonction realloc

Elle permet de réallouer une zone mémoire à une nouvelle taille

void *realloc(void *p, unsigned int n).

Ou p est la zone mémoire allouée dynamiquement et n la nouvelle taille. Cette

fonction permet de conserver les anciennes données. Il permet de tronquer si la
taille est diminuée.

#include <stdlib.h>

int *p,*E;

p = (int*)malloc(sizeof(int));

E= (int*)realloc(p,sizeof(int)*4));

56
Fonction free()

Enfin, lorsque l’on n’a plus besoin de l’espace-mémoire alloué

dynamiquement (c’est-à-dire quand on n’utilise plus le pointeur p), il
faut libérer cette place en mémoire. Ceci se fait à l’aide de l’instruction
free qui a pour syntaxe

free(nom-du-pointeur);

A toute instruction de type malloc ou calloc doit être associé une

instruction de type free.

57
Tableau et allocation dynamique

Exemple : créer un tableau d’entiers à n éléments où n est une variable du

programme.
#include <stdlib.h>
main()
{
int n;
int *tab;
...
tab = (int*)malloc(n * sizeof(int));
...
free(tab);
}

58
Exercice

Ecrire un programme en c permettant d’afficher le

contenu d’un tableau après exploitation de la fonction
calloc à un pointeur de type tableau. Afficher ensuit le
tableau en ajoutant 2 à chaque valeur.

59