Exercice langage C: fichiers sequentiels

 


Exercice 1

Créer sur disquette puis afficher à l'écran le fichier INFORM.TXT dont les informations sont structurées de la manière suivante:

Numéro de matricule (entier)

Nom (chaîne de caractères)

Prénom (chaîne de caractères)

Le nombre d'enregistrements à créer est à entrer au clavier par l'utilisateur.


Exercice 2

Ecrire un programme qui crée sur disquette un fichier INFBIS.TXT qui est la copie exacte (enregistrement par enregistrement) du fichier INFORM.TXT.


Exercice 3

Ajouter un nouvel enregistrement (entré au clavier) à la fin de INFORM.TXT et sauver le nouveau fichier sous le nom INFBIS.TXT.


Exercice 4

Insérer un nouvel enregistrement dans INFORM.TXT en supposant que le fichier est trié relativement à la rubrique NOM et sauver le nouveau fichier sous le nom INFBIS.TXT.


Exercice 5

Supprimer dans INFORM.TXT tous les enregistrements:

a) dont le numéro de matricule se termine par 8

b) dont le prénom est "Paul" (utiliser strcmp)

c) dont le nom est un palindrome. Définir une fonction d'aide PALI qui fournit le résultat 1 si la chaîne transmise comme paramètre est un palindrome, sinon la valeur zéro.

Sauver le nouveau fichier à chaque fois sous le nom INFBIS.TXT.


Exercice 6

Créer sur disquette puis afficher à l'écran le fichier FAMILLE.TXT dont les informations sont structurées de la manière suivante:

Nom de famille

Prénom du père

Prénom de la mère

Nombre d'enfants

Prénoms des enfants

Le nombre d'enregistrements à créer est entré au clavier.

Attention: Le nombre de rubriques des enregistrements varie avec le nombre d'enfants !


Exercice 7

Ecrire un programme qui crée sur disquette le fichier MOTS.TXT contenant une série de 50 mots au maximum (longueur maximale d'un mot: 50 caractères). La saisie des mots se terminera à l'introduction du symbole '*' qui ne sera pas écrit dans le fichier.


Exercice 8

Ecrire un programme qui affiche le nombre de mots, le nombre de palindromes ainsi que la longueur moyenne des mots contenus dans le fichier MOTS.TXT. Utiliser les deux fonctions d'aide PALI et LONG_CH définies au chapitre 10.


Exercice 9

Ecrire un programme qui charge les mots du fichier MOTS.TXT dans la mémoire centrale, les trie d'après la méthode par propagation (méthode de la bulle - voir exercice 7.15) et les écrit dans un deuxième fichier MOTS_TRI.TXT sur la disquette. Les mots seront mémorisés à l'aide d'un tableau de pointeurs sur char et la mémoire nécessaire sera réservée de façon dynamique.


Exercice 10

A l'aide d'un éditeur de textes, créer un fichier NOMBRES.TXT qui contient une liste de nombres entiers. Dans le fichier, chaque nombre doit être suivi par un retour à la ligne. Ecrire un programme qui affiche les nombres du fichier, leur somme et leur moyenne.


Exercice 11

Ecrire un programme qui remplace, dans un fichier contenant un texte, les retours à la ligne par des espaces. Si plusieurs retours à la ligne se suivent, seulement le premier sera remplacé. Les noms des fichiers source et destination sont entrés au clavier.

 


Exercice 12

Ecrire un programme qui détermine dans un fichier un texte dont le nom est entré au clavier, le nombre de phrases terminées par un point, un point d'interrogation ou un point d'exclamation.

Utiliser une fonction d'aide FIN_PHRASE qui décide si un caractère transmis comme paramètre est un des séparateurs mentionnés ci-dessus. FIN_PHRASE retourne la valeur (logique) 1 si le caractère est égal à '.', '!' ou '?' et 0 dans le cas contraire.

 


Exercice 13

Ecrire un programme qui détermine dans un fichier un texte dont le nom est entré au clavier

- le nombre de caractères qu'il contient,

- le nombre de chacune des lettres de l'alphabet

(sans distinguer les majuscules et les minuscules),

- le nombre de mots,

- le nombre de paragraphes (c.-à-d.: des retours à la ligne),

Les retours à la ligne ne devront pas être comptabilisés dans les caractères. On admettra que deux mots sont toujours séparés par un ou plusieurs des caractères suivants

- fin de ligne

- espace

- ponctuation: . : , ; ? !

- parenthèses: ( )

- guillemets: "

- apostrophe: '

Utiliser une fonction d'aide SEPA qui décide si un caractère transmis comme paramètre est l'un des séparateurs mentionnés ci-dessus. SEPA restituera la valeur (logique) 1 si le caractère est un séparateur et 0 dans le cas contraire. SEPA utilise un tableau qui contient les séparateurs à détecter.

Exemple:

      Nom du fichier texte : A:LITTERA.TXT
Votre fichier contient:
12 paragraphes
571 mots
4186 caractères
dont
279 fois la lettre a
56 fois la lettre b
. . .
3 fois la lettre z
et 470 autres caractères

 


Exercice 14

Ecrire un programme qui affiche le contenu d'un fichier texte sur un écran de 25 lignes et 80 colonnes en attendant la confirmation de l'utilisateur (par 'Enter') après chaque page d'écran. Utiliser la fonction getchar.


Exercice 15

Ecrire un programme qui vérifie la validité d'une série de numéros de CCP mémorisés dans un fichier. Un numéro de CCP est composé de trois parties: un numéro de compte, un séparateur '-' et un numéro de contrôle. Un numéro de CCP est correct:

- si le reste de la division entière de la valeur devant le séparateur '-' par 97 est différent de zéro et égal à la valeur de contrôle.

- si le reste de la division par 97 est zéro et la valeur de contrôle est 97.

Exemple:

Nombre de CCP 15742-28 :

15742 modulo 97 = 28
correct
Nombre de CCP 72270-5 :
72270 modulo 97 = 5
correct
Nombre de CCP 22610-10 :
22610 modulo 97 = 9
incorrect
Nombre de CCP 50537-0 :
50537 modulo 97 = 0


nombre incorrect, car la valeur de contrôle devrait être 97.

Nombre de CCP 50537-97 :
50537 modulo 97 = 0
correct

Utiliser une fonction CCP_TEST qui obtient comme paramètres les deux parties numériques d'un nombre de CCP et qui affiche alors un message indiquant si le numéro de CCP est valide ou non.

Pour tester le programme, créer à l'aide d'un éditeur de texte un fichier CCP.TXT qui contient les numéros ci-dessus, suivis par des retours à la ligne.

 


Exercice 16

Deux fichiers FA et FB dont les noms sont à entrer au clavier contiennent des nombres entiers triés dans l'ordre croissant. Ecrire un programme qui copie le contenu de FA et FB respectivement dans les tableaux TABA et TABB dans la mémoire centrale. Les tableaux TABA et TABB sont fusionnés dans un troisième tableau trié en ordre croissant TABC. Après la fusion, la tableau TABC est sauvé dans un fichier FC dont le nom est à entrer au clavier.

La mémoire pour TABA, TABB et TFUS dont les nombres d'éléments sont inconnus, est réservée dynamiquement après que les longueurs des fichiers FA et FB ont été détectées.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\INFORM.TXT"; 
  FILE *FICHIER;
   /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;
  int I,N_ENR;
 
  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "w");
  if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
   /* Saisie des données et création du fichier */
  printf("*** Création du fichier %s ***\n", NOM_FICH);
  printf("Nombre d'enregistrements à créer : ");
  scanf("%d",&N_ENR);
  for (I=1; I<=N_ENR; I++)
    {
     printf("Enregistrement No: %d \n", I);
     printf("Numéro de matricule : ");
     scanf("%d",&MATRICULE);      
     printf("Nom    : ");
     scanf("%s",NOM);
     printf("Prénom : ");
     scanf("%s",PRENOM);
     fprintf(FICHIER, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
     }
  /* Fermeture du fichier */
  fclose(FICHIER);
 
  /* Ouverture du fichier en lecture */
  FICHIER = fopen(NOM_FICH, "r");
  if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
   /* Affichage du fichier */
  printf("*** Contenu du fichier  %s ***\n", NOM_FICH);
  while (!feof(FICHIER))
    {
     fscanf(FICHIER, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     printf("Matricule : %d\t", MATRICULE);
     printf("Nom et prénom : %s %s\n", NOM, PRENOM);
    }
  /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
} 
 
 

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
   /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;
 
  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }
 
  /* Copie de tous les enregistrements */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
    }
 /* Fermeture des fichiers */
 fclose(OUTFILE);
 fclose(INFILE);
  return 0;
} 

 


 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char NOM[30], PRENOM[30];
 
  int MATRICULE;
  char NOM_NOUV[30], PRE_NOUV[30];
  int MATRI_NOUV;
  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }
 
  /* Saisie de l'enregistrement à ajouter */
  printf("Enregistrement à ajouter : \n");
  printf("Numéro de matricule : ");
  scanf("%d",&MATRI_NOUV);      
  printf("Nom    : ");
  scanf("%s",NOM_NOUV);
  printf("Prénom : ");
  scanf("%s",PRE_NOUV);
  /* Copie des enregistrements de l'ancien fichier */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
    }
  /* Ecriture du nouvel enregistrement à la fin du fichier */
  fprintf(OUTFILE,"%d\n%s\n%s\n",MATRI_NOUV,NOM_NOUV,PRE_NOUV);
  /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
} 

 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;
  char NOM_NOUV[30], PRE_NOUV[30];
  int MATRI_NOUV;
  int TROUVE;
 
  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
 
  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }
 
  /* Saisie de l'enregistrement à insérer */
  printf("Enregistrement à ajouter : \n");
  printf("Numéro de matricule : ");
  scanf("%d",&MATRI_NOUV);      
  printf("Nom    : ");
  scanf("%s",NOM_NOUV);
  printf("Prénom : ");
  scanf("%s",PRE_NOUV);
 
  /* Copie des enregistrements dont le nom */
  /* précéde lexicogr. celui à insérer.    */
  TROUVE = 0;
  while (!feof(INFILE) && !TROUVE)
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (strcmp(NOM, NOM_NOUV) > 0)
         TROUVE = 1;
     else
         fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }
 
  /* Ecriture du nouvel enregistrement, */
  fprintf(OUTFILE,"%d\n%s\n%s\n",MATRI_NOUV,NOM_NOUV,PRE_NOUV);
  /* et du dernier enregistrement lu. */
  if (TROUVE)
      fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
 
  /* Copie du reste des enregistrements */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
    }
 
  /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
} 

 


a) Supprimer les enregistrements, dont le numéro de matricule se termine par 8

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;
 
  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }
  /* Copie de tous les enregistrements à l'exception */
  /* de ceux dont le numéro de matricule se termine  */
  /* par 8. */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (MATRICULE%10 != 8)
        fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }
  /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
} 

b) Supprimer les enregistrements, dont le prénom est "Paul" (utiliser strcmp)



 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 main()
{
  /* Déclarations */
  . . .
  /* Ouverture de l'ancien fichier en lecture */
  . . .
  /* Ouverture du nouveau fichier en écriture */
  . . .
  /* Copie de tous les enregistrements à l'exception */
  /* de ceux dont le prénom est 'Paul'. */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (strcmp(PRENOM,"Paul") != 0)
        fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }
   /* Fermeture des fichiers */
  . . .
} 

c) Supprimer les enregistrements, dont le nom est un palindrome. Définir une fonction d'aide PALI qui fournit le résultat 1 si la chaîne transmise comme paramètre est un palindrome, sinon la valeur zéro.

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototype de la fonction PALI */
  int PALI(char *CH);
   /* Déclarations */
  . . .
  /* Ouverture de l'ancien fichier en lecture */
   . . .
  /* Ouverture du nouveau fichier en écriture */
  . . .
  /* Copie de tous les enregistrements à l'exception */
  /* des palindromes. */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (!PALI(NOM))
        fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }
   /* Fermeture des fichiers */
  . . .
} 
int PALI(char *CH)
{
 /* Variable locale */
 char *CH2;
 /* Placer CH2 à la fin de la chaîne */
 for (CH2=CH; *CH2; CH2++)
     ;
 CH2--;
 /* Contrôler si la chaîne désignée par CH est un palindrome */
 for (; CH<CH2; CH++,CH2--)
      if (*CH != *CH2) return 0;
 return 1;
}

 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\FAMILLE.TXT"; 
  FILE *FICHIER;
  /* Autres variables */
  char NOM[30], PERE[30], MERE[30], ENFANT[30];
  int J,N_ENFANTS;
  int I,N_ENR;
 
  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "w");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
 
  /* Saisie des données et création du fichier */
  printf("*** Création du fichier %s ***\n", NOM_FICH);
  printf("Nombre d'enregistrements à créer : ");
  scanf("%d",&N_ENR);
  for (I=1; I<=N_ENR; I++)
    {
     printf("Enregistrement No: %d \n", I);
     printf("Nom de famille : ");
     scanf("%s", NOM);      
     printf("Prénom du père : ");
     scanf("%s", PERE);
     printf("Prénom de la mère : ");
     scanf("%s", MERE);
     printf("Nombre d'enfants : ");
     scanf("%d", &N_ENFANTS);
     fprintf(FICHIER, "%s\n%s\n%s\n%d\n",
                                   NOM, PERE, MERE, N_ENFANTS);
     for (J=1; J<=N_ENFANTS; J++)
         {
          printf("Prénom %d. enfant : ", J);
          scanf("%s", ENFANT);
          fprintf(FICHIER, "%s\n", ENFANT);
         }
    }
  /* Fermeture du fichier */
  fclose(FICHIER);
  /* Réouverture du fichier */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Affichage du fichier */
  printf("*** Contenu du fichier  %s ***\n", NOM_FICH);
  while (!feof(FICHIER))
    {
     fscanf (FICHIER, "%s\n%s\n%s\n%d\n",
                                   NOM, PERE, MERE, &N_ENFANTS);
      printf("\n");
     printf("Nom de famille : %s\n", NOM);
     printf("Nom du père    : %s %s\n", PERE, NOM);
     printf("Nom de la mère : %s %s\n", MERE, NOM);
     printf("Noms des enfants : \n", N_ENFANTS);
     for (J=1; J<=N_ENFANTS; J++)
         {
          fscanf(FICHIER, "%s\n", ENFANT);
          printf("\t%d. : %s %s\n", J, ENFANT, NOM);
         }
    }
  /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
}

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\MOTS.TXT"; 
  FILE *FICHIER;
  /* Autres variables */
  char CHAINE[50];
 
  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "w");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Saisie des données et création du fichier */
  printf("*** Création du fichier %s ***\n", NOM_FICH);
  do
    {
     printf("Entrez un mot ('*' pour finir) : ");
     scanf("%s", CHAINE);
     if (CHAINE[0] != '*')
         fprintf(FICHIER, "%s\n", CHAINE);
    }
  while (CHAINE[0] != '*');
  /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
}

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototypes des fonctions appelées */
  int PALI(char *CH);
  int LONG_CH(char *CH);
   /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\MOTS.TXT"; 
  FILE *FICHIER;
  /* Autres variables */
  char CHAINE[50];
  int N_PALI; /* nombre de palindromes */
  int N_MOTS; /* nombre de mots */
  int L_TOT;  /* longueur totale de tous les mots */
 
  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Compter les palindromes et accumuler */
  /* les longueurs des mots. */
  L_TOT =0;
  N_PALI=0;
  N_MOTS=0;
  while (!feof(FICHIER))
    {
     fscanf(FICHIER, "%s\n", CHAINE);
     N_MOTS++;
     L_TOT  += LONG_CH(CHAINE);
     N_PALI += PALI(CHAINE);
    }
   /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage des résultats */
  printf("Le fichier %s contient :\n", NOM_FICH);
  printf("\t%d \tmots d'une longueur moyenne de :\n", N_MOTS);
  printf("\t%.1f \tcaractères et\n", (float)L_TOT/N_MOTS);
  printf("\t%d \tpalindromes\n", N_PALI);
  return 0;
}
int PALI(char *CH)
{
 /* Variable locale */
 char *CH2;
 /* Placer CH2 à la fin de la chaîne */
 for (CH2=CH; *CH2; CH2++)
     ;
 CH2--;
 /* Contrôler si la chaîne désignée par CH est un palindrome */
 for (; CH<CH2; CH++,CH2--)
      if (*CH != *CH2) return 0;
 return 1;
}
int LONG_CH(char *CH)
{
 char *P;
 for (P=CH ; *P; P++) ;
 return P-CH;
}

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\MOTS.TXT";
  char NOUVEAU[] = "A:\\MOTS_TRI.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Tableau de pointeurs */
  char *TAB[50];
  /* Autres variables */
  char CHAINE[50];
  char *AIDE; /* pour la permutation */ 
  int N_MOTS; /* nombre de mots du fichier */
  int I; /* ligne à partir de laquelle TAB est trié */
  int J; /* indice courant */
  int FIN; /* ligne où la dernière permutation a eu lieu */
    /* permet de ne pas trier un sous-ensemble déjà trié */
 
 
  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Initialisation du du compteur des mots */
  N_MOTS = 0;
  /* Lecture du fichier dans la mémoire centrale */
  while (!feof(INFILE))
     {
      fscanf (INFILE, "%s\n", CHAINE);
      /* Réservation de la mémoire */
      TAB[N_MOTS] = malloc(strlen(CHAINE)+1);
      if (TAB[N_MOTS])
          strcpy(TAB[N_MOTS], CHAINE);
      else
          {
           printf("\aPas assez de mémoire \n");
           exit(-1);
          }
      N_MOTS++;
     }
  /* Fermeture du fichier */
  fclose(INFILE);
  /* Tri du tableau par propagation de l'élément maximal. */
  for (I=N_MOTS-1 ; I>0 ; I=FIN)
      {
       FIN=0;
       for (J=0; J<I; J++)
           if (strcmp(TAB[J],TAB[J+1])>0)
             {
              FIN=J;
              AIDE     = TAB[J];
              TAB[J]   = TAB[J+1];
              TAB[J+1] = AIDE;
             }
      }
   /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }
  /* Copie du tableau dans le nouveau fichier */
  for (I=0; I<N_MOTS; I++)
       fprintf(OUTFILE, "%s\n", TAB[I]);
  /* Fermeture du fichier */
  fclose(OUTFILE);
   return 0;
} 

 





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[]  = "A:\\NOMBRES.TXT";
  FILE *FICHIER;
  /* Autres variables */
  int NOMBRE; /* nombre actuel lu dans le fichier */
  int N;      /* compteur des nombres */
  long SOMME; /* somme des nombres */
 
  /* Ouverture de l'ancien fichier en lecture */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Lecture du fichier et comptabilité */
  N=0;
  SOMME=0;
  while (!feof(FICHIER))
     {
      fscanf (FICHIER, "%d\n", &NOMBRE);
      SOMME += NOMBRE;
      N++;
     }
  /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage des résultats */
  printf("Le fichier %s contient %d nombres.\n", NOM_FICH, N);
  printf("La somme des nombres est   : %ld\n", SOMME);
  printf("La moyenne des nombres est : %f\n", (float)SOMME/N);
  return 0;
} 

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <stdio.h>
 
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[30], NOUVEAU[30]; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char C; /* caractère lu dans le fichier */
  char N_RET; /* Compteur des retours à la ligne consécutifs */
 
  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier source : ");
     scanf("%s", ANCIEN);
     INFILE = fopen(ANCIEN, "r"); 
     if (!INFILE) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", ANCIEN);
    }
  while (!INFILE);
   /* Ouverture du nouveau fichier en écriture */
  do
    {
     printf("Nom du nouveau fichier : ");
     scanf("%s", NOUVEAU);
     OUTFILE = fopen(NOUVEAU, "w"); 
     if (!OUTFILE) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOUVEAU);
    }
  while (!OUTFILE);
 
 
  /* Copier tous les caractères et remplacer le */
  /* premier retour à la ligne d'une suite par  */
  /* un espace. */ 
  N_RET=0;
  while (!feof(INFILE))
    {
     C=fgetc(INFILE);
     if (!feof(INFILE))
        {
         if (C == '\n')
            {
             N_RET++;
             if (N_RET > 1)
                fputc('\n', OUTFILE);
             else
                fputc(' ', OUTFILE);
            }
         else
            {
             N_RET=0; 
             fputc(C, OUTFILE);
            }
        }
    }
   /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
} 
 
Remarque :
 
Après la lecture par fgetc, il faut sassurer encore une fois que le caractère lu est différent de EOF. Nous obtenons ainsi une construction un peu lourde:
 
   while (!feof(INFILE))
     {
      C=fgetc(INFILE);
      if (!feof(INFILE))
         {
          . . .
         }
     }
 
Il est possible de réunir plusieurs instructions dans le bloc conditionnel de la structure while, en les séparant par des virgules. En pratique, on retrouve cette solution souvent pour éviter des constructions inutilement lourdes:
 
   while (C=fgetc(INFILE), !feof(INFILE))
     {
          . . .
     }

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>
main()
{
  /* Prototype de la fonction FIN_PHRASE */
  int FIN_PHRASE(char C);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[30]; 
  FILE *FICHIER;
  /* Autres variables */
  char C; /* caractère lu dans le fichier */
  char NP; /* Compteur de phrases */
 
  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier texte : ");
     scanf("%s", NOM_FICH);
     FICHIER = fopen(NOM_FICH, "r"); 
      if (!FICHIER) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOM_FICH);
    }
  while (!FICHIER);
  /* Compter les symboles de fin de phrase */
  NP=0;
  while (!feof(FICHIER))
        NP += FIN_PHRASE(fgetc(FICHIER));
   /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage du résultat */
  printf("Le fichier %s contient %d phrases.\n",  NOM_FICH, NP);
  return 0;
} 
 
int FIN_PHRASE(char C)
{
 return (C=='.' || C=='!' || C=='?');
}

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <stdio.h>
main()
{
  /* Prototype de la fonction FIN_PHRASE */
  int SEPA(char C);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[30]; 
  FILE *FICHIER;
 
  /* Autres variables */
  char C;       /* caractère lu dans le fichier */
  int ABC[26];  /* compteurs des lettres de l'alphabet */
   int NTOT;     /* nombre total des caractères */
  int NAUTRES;  /* nombre des caractères qui ne font pas
                   partie de l'alphabet */
  int NMOTS;    /* nombre des mots */
  int NPARA;    /* nombre de paragraphes (retours à la ligne) */
  int I;        /* indice d'aide */
  int DANS_MOT; /* indicateur logique: */
                /* vrai si la tête de lecture se trouve */
                /* actuellement à l'intérieur d'un mot. */
 
  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier texte : ");
     scanf("%s", NOM_FICH);
     FICHIER = fopen(NOM_FICH, "r"); 
      if (!FICHIER) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOM_FICH);
    }
  while (!FICHIER);
  /* Initialisations des variables */
  for (I=0; I<26; I++)
      ABC[I]=0;
   NTOT    =0;
  NAUTRES =0;
  NMOTS   =0;
  NPARA   =0;
  DANS_MOT=0;
  /* Examination des caractères du fichier */
  while (!feof(FICHIER))
     {
      C=fgetc(FICHIER);
      if (!feof(FICHIER))
         {
          /* Comptage au niveau caractères */
          if (C=='\n')
             NPARA++;
          else
             {
              NTOT++;
              if (C>='a' && C<='z')
                 ABC[C-'a']++;
              else if (C>='A' && C<='Z')
                 ABC[C-'A']++;
              else
                 NAUTRES++;
             }
 
 
          /* Comptage des mots */
          if (SEPA(C))
             {
              if (DANS_MOT)
                 {
                  NMOTS++;
                  DANS_MOT=0;
                 }
             }
          else
             DANS_MOT=1;
         }
      }
   /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage du résultat */
  printf("Votre fichier contient :\n");
  printf("\t%d paragraphes\n", NPARA);
  printf("\t%d mots\n", NMOTS);
  printf("\t%d caractères\ndont\n", NTOT);
  for (I=0; I<26; I++)
       printf("\t%d fois la lettre %c\n", ABC[I], 'a'+I);
  printf("et %d autres caractères\n", NAUTRES);
  return 0;
} 
 
 
int SEPA(char C)
{
 /* Tableau contenant tous les séparateurs de mots */
 char SEP[12] = { '\n', ' ', ',', ';', '.', ':',
                 '?', '!', '(', ')', '"', '\'' };
 int I;
 
 /* Comparaison de C avec tous les éléments du tableau */
 for (I=0 ; C!=SEP[I] && I<12 ; I++) ;
 if (I==12)
     return 0;
 else
     return 1;
  /* ou bien simplement : */
 /* return (I != 12);    */
}

 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <stdio.h>
main()
{
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[30]; 
  FILE *FICHIER;
  /* Autres variables */
  char C;  /* caractère actuel */
  int NLIGNE, NCOLO; /* position actuelle sur l'écran */
 
  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier texte : ");
     scanf("%s", NOM_FICH);
     FICHIER = fopen(NOM_FICH, "r"); 
      if (!FICHIER) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOM_FICH);
    }
  while (!FICHIER)  ;
  getchar();
  /* Initialisations des variables */
  NLIGNE  = 0; NCOLO   = 0;
  /* Affichage du fichier */
  while (!feof(FICHIER))
     {
      C=fgetc(FICHIER);
      if (!feof(FICHIER))
         {
          NCOLO++;
          if (NCOLO==80 || C=='\n') /* fin de la ligne */ 
             {
              NLIGNE++;
              if (NLIGNE==25) /* fin de l'écran */ 
                 {
                  getchar();
                  NLIGNE=1;
                 }
              printf("%c",C);
              NCOLO=1;
             }
          else
             printf("%c",C);
         }
     }
   /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
}

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototype de la fonction CCP_TEST */
  void CCP_TEST(long COMPTE, int CONTROLE);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[]  = "A:\\CCP.TXT";
  FILE *FICHIER;
  /* Autres variables */
  long COMPTE;  /* nombre du compte CCP */
  int CONTROLE; /* nombre de contrôle   */
 
  /* Ouverture du fichier CCP.TXT en lecture */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
 
 
  /* Lecture des nombres et appel de la fonction CCP_TEST  */
  /* A l'aide de la chaîne de format, scanf lit les deux   */
  /* parties du nombre de CCP, les convertit en long resp. */
  /* en int et affecte les résultats aux variables COMPTE  */
  /* et CONTROLE. */
  while (!feof(FICHIER))
     {
      fscanf (FICHIER, "%ld-%d\n", &COMPTE, &CONTROLE);
      CCP_TEST(COMPTE, CONTROLE);
     }
   /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
} 
 
 
void CCP_TEST(long COMPTE, int CONTROLE)
{
 int RESTE;
 RESTE = COMPTE % 97;
 if (RESTE == 0)
     RESTE = 97;
 if (RESTE == CONTROLE)
     printf ("Le nombre CCP %ld-%d est valide\n",
 COMPTE, CONTROLE);
 else
     printf ("Le nombre CCP %ld-%d n'est pas valide\n",
 COMPTE, CONTROLE);
}

 






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototype de la fonction FUSION */
  void FUSION(int *A, int *B, int *FUS, int N, int M);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char FICH_A[30], FICH_B[30], FICH_FUS[30];
  FILE *FA, *FB, *FFUS;
  /* Autres variables */
  int *TABA, *TABB, *TFUS; /* pointeurs pour les tableaux */
  int LA, LB; /* Longueurs de FA et FB */
   int N; /* Nombre lu ou écrit dans un fichier */
  int I; /* Indice d'aide */
 
  /* Ouverture du fichier FA en lecture */
   do
    {
     printf("Nom du fichier FA : ");
     scanf("%s", FICH_A);
     FA = fopen(FICH_A, "r"); 
     if (!FA) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", FICH_A);
    }
  while (!FA);
  /* Détection de la longueur de FA */
  for (LA=0; !feof(FA); LA++)
       fscanf(FA,"%d\n", &N);
  /* Fermeture du fichier FA */
  fclose(FA);
  /* Allocation de la mémoire pour TABA */
  TABA = malloc (LA*sizeof(int));
   if (!TABA)
       {
        printf("\a Pas assez de mémoire pour TABA\n");
        exit(-1);
       }
 
 
  /* Réouverture du fichier FA en lecture */
  FA = fopen(FICH_A, "r");
  /* Copie du contenu de FA dans TABA */
  for (I=0; I<LA; I++)
       fscanf(FA,"%d\n", TABA+I);
  /* Fermeture du fichier FA */
  fclose(FA);
 
  /* Mêmes opérations pour FB : */
  /* Ouverture du fichier FB en lecture */
   do
    {
     printf("Nom du fichier FB : ");
     scanf("%s", FICH_B);
     FB = fopen(FICH_B, "r");
     if (!FB) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", FICH_B);
    }
  while (!FB);
  /* Détection de la longueur de FB */
  for (LB=0; !feof(FB); LB++)
       fscanf(FB,"%d\n", &N);
  /* Fermeture du fichier FB */
  fclose(FB);
  /* Allocation de la mémoire pour TABB */
  TABB = malloc (LB*sizeof(int));
   if (!TABB)
       {
        printf("\a Pas assez de mémoire pour TABB\n");
        exit(-1);
       }
  /* Réouverture du fichier FB en lecture */
  FB = fopen(FICH_B, "r");
  /* Copie du contenu de FB dans TABB */
  for (I=0; I<LB; I++)
       fscanf(FB,"%d\n", TABB+I);
  /* Fermeture du fichier FB */
  fclose(FB);
 
  /* Allocation de la mémoire pour TFUS */
   TFUS = malloc ((LA+LB)*sizeof(int));
  if (!TFUS)
       {
        printf("\a Pas assez de mémoire pour TFUS\n");
        exit(-1);
       }
 
  /* Fusion des tableaux TA et TB dans TFUS */
  FUSION (TABA, TABB, TFUS, LA, LB);
 
 
  /* Ouverture du fichier FFUS en écriture */
   do
    {
     printf("Nom du fichier FFUS : ");
     scanf("%s", FICH_FUS);
     FFUS = fopen(FICH_FUS, "w"); 
     if (!FFUS) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", FICH_FUS);
    }
  while (!FFUS);
  /* Copier le contenu de TFUS dans FFUS */
  for (I=0; I<(LA+LB); I++)
       fprintf(FFUS,"%d\n", *(TFUS+I));
  /* Fermeture du fichier FFUS */
  fclose(FFUS);
   return 0;
} 
 
void FUSION(int *A, int *B, int *FUS, int N, int M)
{
  /* Variables locales */
 /* Indices courants dans A, B et FUS */
 int IA,IB,IFUS;  
 
 /* Fusion de A et B dans FUS */
 IA=0, IB=0; IFUS=0;
 while ((IA<N) && (IB<M))
    if (*(A+IA)<*(B+IB))
        {
         *(FUS+IFUS)=*(A+IA);
         IFUS++;
         IA++;
        }
    else
        {
         FUS[IFUS]=B[IB];
         IFUS++;
         IB++;
        }
 /* Si A ou B sont arrivés à la fin, alors */
 /* copier le reste de l'autre tableau.    */
 while (IA<N)
     {
      *(FUS+IFUS)=*(A+IA);
      IFUS++;
      IA++;
     }
 while (IB<M)
     {
      *(FUS+IFUS)=*(B+IB);
      IFUS++;
      IB++;
     }
}