Vous êtes sur la page 1sur 13

Chapitre 5

Chaîne et chier de caractères

5.1 Introduction
Le caractère est considéré comme la donnée la plus élémentaire en programmation procé-
durale, (bien qu'il soit possible de manipuler directement des bits de donnée). La raison
est que, en terme de mémoire, un caractère peut être codé sur un seul octet, ce qui corres-
pond à la plus petite unité de mémoire adressable. Le langage C compte, parmi ses types
de base, le type char, qui sert à implémenter des caractères sur machine.
Il est, par ailleurs, possible d'agencer un ensemble de caractères pour obtenir l'une des
structures de données les plus usitées en programmation procédurale, à savoir, la chaîne
de caractères. Bien que le langage C n'ore pas un type particulier pour implémenter des
chaînes de caractères, ces dernières sont implémentée à l'aide de tableaux unidimensionnels
de caractères.
Par ailleurs, des chaînes de caractères plus ou moins longues peuvent être sauvegardées
dans des mémoires secondaires, sous la forme de chiers de caractères, plus connus sous
l'appellation de chiers texte. Le langage C met à la disposition du programmeur un
ensemble d'outils permettant de créer et de manipuler de tels chiers, avec la possibilité
de les formater selon le besoin.

5.2 Tout part du caractère


Sur machine, un caractère est codé par un entier dont le code binaire tient sur un seul
octet. Il s'agit du code ASCII ; chaque caractère en a un (voir la table de la Figure 5.1).
De ce fait, le passage d'un caractère à l'entier qui le code est immédiat et il est possible
d'eectuer certaines opérations arithmétiques sur des caractères. A titre d'exemple, si
aleph est une variable du type caractère qui contient le caractère 'a' alors aleph vaut 97
en tant qu'entier et aleph +1 vaut 'b', en tant que caractère.
Le type prévu par le langage C pour implémenter des caractères est le type de base
char. La ligne suivante déclare trois variables de type char et initialise deux d'entre elles
de deux manières diérentes : en utilisant une constante caractère, ('a'), ou en utilisant
le code ASCII de la lettre z .
char lettre, aleph = 'a', z = 122;

Rappelons, enn, que le format d'impression pour les caractères est %c.

1
2 CHAPITRE 5. CHAÎNE & FICHIER DE CARACTÈRES

printf ("%c %d",aleph+1,aleph); // ache b et 97

5.3 Les chaînes de caractères


Une chaîne de caractère est une séquence nie de caractères qui permet de stocker tout
un texte, un mot, c'est-à-dire, un texte ne contenant pas de séparateur, ou simplement
un seul caractère. Une chaîne de caractère peut aussi être vide. Le texte contenu dans
une chaîne de caractères peut être formaté, avec des espaces, des retours à la ligne, des
tabulations, de la ponctuation, etc...

5.3.1 Déclaration et initialisation


Dans le langage C standard, il n'y a pas de type spécialement prévu pour les chaînes de
caractères, mais de tels objets peuvent être implémentés comme des tableaux unidimen-
sionnels de caractères. Il est alors possible de déclarer une chaîne de caractères à l'aide
du constructeur de tableau, [], comme suit :

char chaine[MAX_CHAINE+1];

où MAX_CHAINE est supposée être une constante déjà dénie. Il est aussi possible de déclarer
un pointeur sur caractère, puis de l'initialiser par l'adresse d'une zone mémoire allouée
dynamiquement qui a la taille désirée :

char *chaine = nalloc(n+1,char); // allocation dynamique d'une chaîne

où n est une variable entière contenant le nombre de caractères dédiés à la variable chaîne
proprement dite. Notez que, dans les deux déclarations précédentes, une case supplémen-
taire a été prévue an de mémoriser le caractère de n de chaîne '\0' dont le code ASCII
est 0. Ce dernier est un caractère spécial qui est ajouté à la n de chaque chaîne pour
indiquer la n de celle-ci.
Une fois déclarée, une variable chaîne de caractères peut être manipulée comme un
tableau unidimensionnel de caractères, avec la particularité de se terminer toujours par
le caractère de n de chaîne '\0'. Ainsi, l'accès aux diérents caractères de la chaîne peut
se faire à l'aide des crochets est d'un indice entier, comme dans l'exemple suivant :

for(i=0;i<=25;i++) chaine[i] = i + 65; // initialisation par l'alphabet majuscule

Une chaîne de caractère peut, toutefois, être initialisée autrement, par exemple comme
suit :
char mess[] = "Hello ENIT !", *voyel = "aeiouy", secret[] =
{69,78,73,84,0};

Dans la déclaration précédente, la variable secret a été initialisée en utilisant les codes
ASCII des caractères E, N, I, et T.
5.3. LES CHAÎNES DE CARACTÈRES 3

Figure 5.1  Table des codes ASCII des caractères usuels sous Linux.
4 CHAPITRE 5. CHAÎNE & FICHIER DE CARACTÈRES
1 void ManipChaine1 ( )

2 {

3 int i ;
4 char a l p h a b e t [ 2 7 ] ;
5

6 for ( i = 0 ; i <=25; i ++) // Initialisation de

7 a l p h a b e t [ i ]= i + 65; // la chaine alphabet majuscule

8 alphabet [ 2 6 ] = '\0' ;
9

10 printf ( "%s\n" , a l p h a b e t ) ;
11

12 char ∗ p t r = alphabet ;

13 while ( ∗ p t r )
14 {

15 ∗ ptr = tolower ( ∗ ptr ) ; // Transformation en alphabet minuscule

16 p t r ++;

17 }

18 printf ( "\n%s\n" , a l p h a b e t ) ;
19 }

Figure 5.2  Procédure permettant d'initialiser et de manipuler une chaîne de caractère.

5.3.2 Manipulation des chaînes de caractères


Une fois déclarée, une chaîne de caractères peut être manipulée de diverses façons. On
peut la parcourir caractère par caractère an de l'initialiser ou de la modier comme
le montre la procédure de la Figure 5.2. On peut constater, dans cet exemple, que la
chaîne est parcourue de deux manières diérentes : à l'aide d'un compteur, si l'on sait
combien de caractères on a à traiter, ou bien en utilisant un pointeur sur char, (voir la
boucle commençant à la Ligne 12). Dans ce dernier cas, la boucle s'arrête en atteignant
le caractère nul ('\0').
Une chaîne de caractère peut également être lue, à partir de l'entrée standard, à l'aide
de la fonction scanf(). Toutefois, pour des raisons de sécurité, il est conseillé d'indiquer
le nombre de caractère composant la chaîne dans le format de lecture (voir un exemple à
la Ligne du programme 5.2).

Par ailleurs, le langage C ore une panoplie de fonctions prédénies de manipulation


de chaîne de caractères. L'utilisation de ces fonctions requiert, toutefois, l'inclusion du
chier strings.h. Dans ce qui suit, nous listons les plus utiles de ces fonctions :
 strlen(char *chaine) : retourne la longueur de la chaîne reçue en paramètre.
Cette fonction ne compte pas le caractère de n de chaîne ('\0').
 strcmp(char *chaine1, char *chaine2) : compare deux chaînes caractères par
caractère. Si les deux chaînes sont parfaitement identiques alors la fonction retourne
0. Sinon un nombre entier non nul sera retourné. La valeur absolue de ce nombre
donne l'indice du premier caractère faisant la diérence entre chaine1 et chaine2.
Il est négatif si chaine1 est lexico-graphiquement plus petite que chaine2 et positif
dans le cas inverse.
 strcpy(char *chaineCopie, char *chaine) : eectue la copie d'une chaîne dans
une autre.
 strchr(char *chaine, char ch) : permet de chercher un caractère dans une chaîne.
5.4. LES FICHIERS DE CARACTÈRES 5

La fonction retourne l'adresse de la première occurrence du caractère recherché, si-


non le pointeur NULL.
 strstr(char *chaine, char *sousChaine) : permet de chercher une sous-chaîne
dans une chaîne. La fonction retourne l'adresse de la première occurrence de la
sous-chaîne recherchée, sinon le pointeur NULL.
 Il y a aussi les fonctions strrchr() et strrstr() qui ont le même rôle que strchr()
et strstr(), sauf que la recherche commence à partir de la n de la chaîne.

Les fonctions C qui se trouvent dans la Figure 5.3 illustrons quelques utilisations
possibles des fonctions prédénies manipulant les chaînes de caractères.

5.4 Les chiers de caractères


La plupart des langages de programmation procédurale permettent de stocker, sur mé-
moire secondaire, un nombre éventuellement important de caractères. De telles séquences
de caractères peuvent être stockées sous la forme de chiers texte, qu'il est possible de
formater en utilisant des caractères spéciaux, comme le caractère d'espacement, le carac-
tère de retour à la ligne, la tabulation, le caractère de n de chier, etc... Le programmeur
peut ainsi retrouver ces données formatées et les charger de nouveau en mémoire vive, an
de les modier par exemple, puis de les sauvegarder de nouveau sur mémoire secondaire.

5.4.1 Déclaration et initialisation


Le langage C réserve un type particulier pour la manipulation par programme des chiers
texte. Il s'agit du type FILE, qui est une structure appelée couramment ot. Cette der-
nière sert à regrouper toutes les informations nécessaires pour eectuer des opérations
d'entrée/sortie. An de manipuler un chier texte, on commence par déclarer un poin-
teur sur la structure ot. Ce pointeur sera initialisé à l'aide de la fonction prédénie
fopen(), dont le rôle est de préparer le ot à être utilisé. L'appel à la fonction fopen()
peut s'eectuer comme suit :

FILE *ot = fopen(nomFichier,mode);

où ot est une variable pointeur sur la structure FILE. Lors de l'ouverture d'un chier, il
est nécessaire de préciser deux paramètres :
 Le nom du chier physique, qui est une chaîne de caractère pouvant éventuelle-
ment contenir le chemin d'accès au chier. La fonction fopen() associera alors le
ot pointé par la variable ot au chier physique dont le nom se trouve dans le
paramètre nomFichier.
 Le mode d'accès au chier. Il existe plusieurs modes d'accès possibles qui dépendent
principalement du fait que l'on veut créer un nouveau chier ou que l'on veut ou-
vrir un qui existe déjà. Le Tableau 5.1 résume ces diérents modes d'accès ainsi
que l'eet de chaque mode sur le chier ouvert. La colonne position du Tableau 5.1
indique la position, dans le chier, où la lecture/écriture va avoir lieu. L'indicateur
initialisation veut dire que le chier va être initialisé, ce qui se traduit par la perte
du contenu du chier dans le cas où ce dernier existe déjà. Enn, signalons que les
deux cas qui aboutissent à une erreur, et qui correspondent aux cas où l'on cherche
6 CHAPITRE 5. CHAÎNE & FICHIER DE CARACTÈRES

1 void ManipChaine2 ( )

2 {

3 int i ;
4 char c h a i n e [ 6 4 ] , c o d e [ 6 4 ] ;
5 char m e s s [ ] = "Hello ENIT !" , secret [ ] = {69 , 78 , 73 , 84 , 0};

6 // affichage d ' une chaine caractère par caractère

7 for ( i = 0 ; i <=3; i ++) printf ( "%c\n" , s e c r e t [ i ]) ;

8 // affichage des longueurs de chaines

9 printf ( "%u %u\n" , ( unsigned ) s t r l e n ( s e c r e t ) ,( unsigned ) s t r l e n ( m e s s ) ) ;


10 // strcpy pour faire la copie d ' une chaine

11 strcpy ( chaine , s e c r e t ) ;

12 printf ( "%s\n" , c h a i n e ) ;
13

14 i f ( strcmp ( chaine , mess ) ) // strcmp pour comparer deux chaines

15 printf ( "chaines non identiques \n" ) ;


16 else
17 printf ( "chaines identiques \n" ) ;
18 // Saisie d ' une chaine à partir du clavier

19 printf ( " Saisissez le code secret: " ) ;


20 s c a n f ( "%5s" , c o d e ) ;

21 / / R e c h e r c h e d ' un c a r a c t è r e ou s o u s − c h a i n e d a n s u n e c h a i n e

22 p r i n t f ( "\n%p %p" , s t r c h r ( m es s , '!' ) , s t r s t r ( m es s , c o d e ) ) ;

23 }

24 // Fonction calculant le nombre d ' occurrence d ' une sous −c h a i n e dans une

chaine

25 int NbOccur ( char ∗ c h a i n e , char ∗ s o u s C h a i n e )


26 {

27 int nbOccur = 0;

28

29 while ( ( c h a i n e= s t r s t r ( c h a i n e , sousChaine ) ) )

30 {

31 n b O c c u r++;

32 c h a i n e ++;

33 }

34

35 return nbOccur ;

Figure 5.3  Utilisation des fonctions prédénies pour la manipulation des chaînes de
caractères. Fonction comptant le nombre d'occurrence d'une sous-chaîne dans une chaîne
de caractère.
5.4. LES FICHIERS DE CARACTÈRES 7

Mode d'accès Paramètre Position Eet


ch. existant ch. inexistant
lecture "r" début  erreur
écriture "w" début initialisation création
"a" n  création
lecture "r+" début  erreur
et "w+" début initialisation création
écriture "a+" n  création

Table 5.1  Modes d'accès à un chier texte. Les caractères r et w désignent la possibilité
de lecture est l'écriture respectivement. Le caractère + indique qu'il est possible de lire et
d'écrire à la fois.

à lire à partir d'un chier inexistant, se traduisent par le renvoie de la valeur NULL
par la fonction fopen().

L'opération symétrique de l'ouverture d'un ot est sa fermeture. Ainsi, chaque ot
doit être fermé en n d'utilisation en exécutant l'instruction suivante :
fclose(ot);

Remarque : il existe deux ots prédénis par le langage C, qui sont respectivement le
ot entrée standard stdin et le ot de sortie standard stdout. Pour ces deux ots, qui
sont habituellement respectivement associés au clavier et à l'écran, nul besoin de les ouvrir
avec fopen() ni de les fermer avec fclose().

5.4.2 Création d'un chier texte


An de créer un nouveau chier texte, on commence par déclarer un pointeur sur un ot,
comme indiqué dans la section précédente. Le mode d'accès doit, toutefois, être l'un des
quatre modes qui permettent l'opération d'écriture et qui n'aboutissent pas à une erreur
si le chier est inexistant. Ces modes sont "w", "w+","a" et "a+" (voir Table 5.1). La
principale diérence entre les modes "w" et "w+", d'une part et les modes "a" et "a+"
d'autres parts, est que ces deux derniers permettent d'ajouter des caractères à la n de
chiers qui existent déjà sans perdre son contenu initial.

Un chier texte peut être créer de diverses façons. Dans ce qui suit, nous en détaillons
trois, qui sont les suivantes :
 Création caractère par caractère : on peut alors faire appel à la fonction
fputc() :

fputc(ch,ot); // écriture du caractère ch dans un ot

à laquelle il sut de passer le caractère à écrire et un pointeur sur le ot dans


lequel écrire.
 Création mot par mot : rappelons, tout d'abord, que nous désignons par mot
une chaîne de caractère qui ne contient de séparateur. L'écrture d'un mot dans un
ot peut se faire par un appel à la fonction fprintf () :
8 CHAPITRE 5. CHAÎNE & FICHIER DE CARACTÈRES

fprintf (ot,"%s ",mot); // écriture de la chaîne mot dans un ot

qui opère comme la fonction printf (), (voir Chapitre 1), sauf que l'écriture se passe
sur un ot quelconque et non pas sur le ot de sortie standard stdout. Notez que
la chaîne indiquant le format d'écriture contient un espace qui sera imprimé dans
le ot pour que les mots ne soient pas collés les uns aux autres.
 Création ligne par ligne : il est alors possible d'utiliser la fonction fputs()
comme suit :
fputs(ligne,ot); // écriture de la chaîne ligne dans un ot

à laquelle il faut passer la ligne à écrire et un pointeur sur le ot dans lequel écrire.
Il est important de savoir que cette fonction ajoute, au ot, un caractère n-de-
ligne, ('\n'), après chaque écriture.

Le code de la Figure 5.4 contient trois procédures C implémentant chacune des trois
façons de créer un chier texte décrite ci-dessus. A chaque fois, les caractères à écrire sont
récupérés sur l'entrée standard, stdin, à l'aide de la fonction d'entrée appropriée : getc(),
scanf () ou fgets().

Remarque : éviter d'utiliser la fonction gets() pour lire une ligne à partir de l'entrée
standard, car cette dernière ne contrôle pas le nombre de caractère lu. À la place, utilisez
fgets() (voir la Ligne 45 du Programme 5.4, pour un exemple d'utilisation).

5.4.3 Lecture d'un chier texte


Quand un programme utilise des données de grande taille, il est fréquent que ces don-
nées se trouvent initialement dans des chiers texte stockés sur mémoire secondaire. Il est
donc nécessaire de récupérer ces données là où elles se trouvent. Ceci peut se faire, par
programme C, à l'aide de procédures utilisant la structure de ot. Le mode d'accès lors
de l'ouverture de ces chiers doit, toutefois, être l'un des modes qui permettent la lecture
à partir d'un chier existant. Ces modes d'accès sont "r", "r+" ou "a+".

Un chier texte peut être lu de diverses façons. Dans ce qui suit, nous en détaillons
trois, qui sont les suivantes :
 Lecture caractère par caractère : on peut alors faire appel à la fonction fgetc()
qui, justement, permet une lecture caractère par caractère :

fgetc(ot) // retourne un caractère lu sur un ot

à laquelle il sut d'indiquer le ot à partir duquel la lecture doit être faire. Si-
gnalons que, quand la lecture atteint la n du chier associé au ot en lecture, la
fonction fgetc() retourne la constante EOF. Cette dernière est une constante pré-
dénie qui indique la n du chier ; sa valeur est Ctrl+Z (code ASCII 26) sous
Windows et Ctrl+D (code ASCII 4) sous Linux.
 Lecture mot par mot : une telle lecture peut se faire à l'aide de la fonction
fscanf () :
5.4. LES FICHIERS DE CARACTÈRES 9

1 // Creation d ' un fichier texte caractère par caractère

2 void CreerFlotChar ( char nomFlot [ ] )

3 {

4 char c ;

5 FILE ∗flot ;

7 if (( f l o t = f o p e n ( nomFlot , "w" ) ) )
8 {

9 printf ( "Tapez un texte qui se termine par Ctrl+Z\n" ) ;


10

11 while ( ( c=g e t c ( s t d i n ) ) != EOF)

12 fputc (c , f l o t ) ;

13

14 fclose ( flot ) ;

15 }

16 else
17 printf ( "Echec de l'ouveture du fichier en écriture \n'" ) ;
18 }

19

20 // Création d ' un fichier texte mot par mot

21 void CreerFlotChaine ( char nomFlot [ ] )

22 {

23 char c h a i n e [MAX_CHAINE+ 1 ] ;

24 FILE ∗flot ;

25

26 i f ( ( f l o t =f o p e n ( nomFlot , "w" ) ) )
27 {

28 while ( s c a n f ( "%s" , c h a i n e ) != EOF)

29 fprintf ( flot , "%s " , c h a i n e ) ;


30

31 fclose ( flot ) ;

32 }

33 else
34 printf ( "Fichier non créé\n" ) ;
35 }

36

37 // Création d ' un fichier texte ligne par ligne

38 void CreerFlotLigne ( char nomFlot [ ] )

39 {

40 char l i g n e [ MAX_LIGNE+ 1 ] ;

41 FILE ∗flot ;

42

43 i f ( ( f l o t =f o p e n ( nomFlot , "w" ) ) )
44 {

45 while ( f g e t s ( l i g n e , MAX_LIGNE+1 , s t d i n ) != NULL)

46 fputs ( ligne , f l o t ) ;

47

48 fclose ( flot ) ;

49 }

50 else
51 printf ( "Fichier non créé\n" ) ;
52 }

Figure 5.4  Création de chier texte de trois façons diérentes : caractère par caractère,
mot par mot et ligne par ligne.
10 CHAPITRE 5. CHAÎNE & FICHIER DE CARACTÈRES

fscanf (ot,"%s",mot)

qui opère comme la fonction scanf () (voir Chapitre 1), sauf que la lecture se passe
sur un ot quelconque et non pas sur le ot entrée standard stdin. Signalons que,
quand la lecture atteint la n du chier associé à ot, la fonction fscanf () retourne
la constante EOF.
 Lecture ligne par ligne : il est alors possible d'utiliser la fonction fgets() :

fgets(ligne,MAX_LIGNE+1,ot)

à laquelle il faut passer comme paramètre, la variable chaîne de caractère qui va


recevoir les caractères lus, ainsi que le nombre maximum de caractère à lire. Si-
gnalons que, quand la lecture atteint la n du chier associé au ot en lecture, la
fonction fgets() retourne la constante NULL.

Le code détaillé dans la Figure 5.5 contient trois procédures C implémentant les trois
façons de lire un chier texte décrite ci-dessus. A chaque fois, les caractères lus sont achés
sur la sortie standard, stdout, pour s'assurer du bon déroulement de la lecture.

5.4.4 Modication d'un chier texte


En manipulant des chiers texte, on peut avoir besoin de modier leurs contenus puis de
les sauvegarder sous leurs versions modiées. Avec le langage C, il est possible de réaliser
une telle manipulation en utilisant la structure de ot avec le mode d'accès approprié.
Ainsi, il est par exemple possible d'ajouter des données (des caractères) à la n d'un chier
texte existant. On peut aussi modier des chiers existant dans des endroits particuliers
du texte qu'ils contiennent. Dans ce qui suit, nous détaillons ces deux façons de modier
un chier texte.
 Modication par ajout en n de chier : ceci requiert l'ouverture du chier en
mode "a" ou "a+". A part le mode d'accès, l'ajout de caractère en n de chier peut
s'eectuer exactement comme si on créait un nouveau chier, sauf que le contenu
initial du chier sera conservé. La Figure 5.6 détaille une procédure ajoutant des
caractères saisis à partir de l'entrée standard, (stdin), à la n d'un chier texte.
 Modication de partie du texte : une autre façon de modier un texte consiste
à modier des zones particulières du texte. Pour ce faire, on peut utiliser le mode
d'accès "r+", qui permet la lecture et l'écriture à n'imoprte quel endroit du texte.

FILE *ot = fopen(nomFichier,"r+");

Ensuite, an de se positionner au début de la zone de texte qu'on veut modier,


on fait recours à la fonctions C prédénie fseek() :

fseek(ot,decalage,position);

qui permet de modier la position courante dans le chier en eectuant un dé-


calage, exprimé en nombre d'octet, à partir d'une position relative. Le paramètre
position peut avoir trois valeurs possibles, qui sont 0, pour eectuer un décalage
5.4. LES FICHIERS DE CARACTÈRES 11

1 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

2 // Parcours de fichier texte

3 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

4 void ParcourFlotChar ( char nomFlot [ ] )

5 {

6 char c ;

7 FILE ∗flot ;

9 i f ( ( f l o t =f o p e n ( nomFlot , "r" ) ) )
10 {

11 while ( ( c= f g e t c ( f l o t ) ) != EOF)

12 fputc ( c , stdout ) ;

13

14 fclose ( flot ) ;

15 }

16 else
17 printf ( "Fichier non ouvert\n" ) ;
18 }

19

20 void ParcourFlotChaine ( char nomFlot [ ] )

21 {

22 char c h a i n e [MAX_CHAINE+ 1 ] ;

23 FILE ∗flot ;

24

25 i f ( ( f l o t =f o p e n ( nomFlot , "r" ) ) )
26 {

27 while ( f s c a n f ( f l o t , "%s" , c h a i n e ) != EOF)

28 printf ( "%s " , c h a i n e ) ;


29

30 fclose ( flot ) ;

31 }

32 else
33 printf ( "Fichier non ouvert\n" ) ;
34 }

35

36 void ParcourFlotLigne ( char nomFlot [ ] )

37 {

38 char l i g n e [ MAX_LIGNE+ 1 ] ;

39 FILE ∗flot ;

40

41 i f ( ( f l o t =f o p e n ( nomFlot , "r" ) ) )
42 {

43 while ( f g e t s ( l i g n e , MAX_LIGNE+1 , f l o t ) != NULL)

44 fputs ( ligne , stdout ) ;

45

46 fclose ( flot ) ;

47 }

48 else
49 printf ( "Fichier non ouvert\n" ) ;
50 }

Figure 5.5  Lecture de chier texte de trois façons diérentes : caractère par caractère,
mot par mot et ligne par ligne.
12 CHAPITRE 5. CHAÎNE & FICHIER DE CARACTÈRES
1 void AjoutFlotFin ( char nomFlot [ ] )

2 {

3 char c ;

4 FILE ∗flot ;

6 if (( f l o t = f o p e n ( nomFlot , "a" ) ) )
7 {

8 printf ( "Ajouter un texte qui se termine par Ctrl+Z\n" ) ;


9

10 while ( ( c=g e t c ( s t d i n ) ) != EOF)

11 fputc (c , f l o t ) ;

12

13 fclose ( flot ) ;

14 }

15 else
16 printf ( "Echec de l'ouveture du fichier en mode ajout .\n'" ) ;
17 }

Figure 5.6  Procédure C eectuant un ajout de caractères en n de chier.

à partir du début du chier, 1, pour eectuer un décalage à partir de la position


courante dans le chier, enn, 2, pour eectuer un décalage à partir de la n du
chier. Dans ce dernier cas, le décalage doit être exprimé par un entier négatif.

La procédure C détaillée dans la Figure 5.7 permet de remplacer une ligne entière
d'un chier texte existant par une autre. Comme elle est dénie, la procédure
suppose, toutefois, que les lignes du chier à modier ont toutes la même taille.
Cette taille est déterminée par la lecture de la première ligne du chier (voir Ligne
9). Pour déterminer le nombre total de caractères à dépasser, on multiplie la taille
d'une ligne augmentée de 1, (pour compter le caractère \n), par le numéro de la
ligne qu'on veut remplacer. La fonction fseek() est alors appelée pour eectuer le
décalage (voir Ligne 11), après quoi, le remplacement de la ligne est assuré par la
fonction fputs(), (voir Ligne 12).

Exercice 1. Étant donnée un chier texte existant, on voudrait localiser, dans


ce chier, toutes les occurrences d'une chaîne de caractère donnée, en achant
le numéro de ligne et le numéro de colonne pour chaque occurrence. Écrire une
procédure C qui réalise cette tâche.
5.4. LES FICHIERS DE CARACTÈRES 13

1 void ModifFlotLigne ( char nomFlot [ ] , char nouvLigne [ ] , int numLigne )

2 {

3 long tailLigne ;

4 char l i g n e [ MAX_LIGNE+ 1 ] ;

5 FILE ∗flot ;

7 i f ( ( f l o t =f o p e n ( nomFlot , "r+" ) ) )
8 {

9 f g e t s ( l i g n e , MAX_LIGNE+1 , f l o t ) ;

10 tailLigne = strlen ( ligne ) + 1;

11 f s e e k ( f l o t , numLigne ∗ tailLigne ,0) ;

12 f p u t s ( nouvLigne , f l o t ) ;

13 fclose ( flot ) ;

14 }

15 else
16 printf ( "Fichier non ouvert\n" ) ;
17 }

Figure 5.7  Procédure C eectuant le remplacement d'une ligne par une autre dans un
chier texte.

Vous aimerez peut-être aussi