Notes sur le langage C

Il est courant en C standard d'utiliser le flux stdin pour acquérir des données en provenance d'un opérateur. (Mode conversationnel). On admettra pour la suite que stdin est connecté à la partie 'clavier' d'un périphérique console.

Le langage C offre plusieurs fonctions permettant de lire des données sur un flux en général et sur stdin en particulier :

• fgetc() ;
• getc() ;
• getchar() ;
• gets() ;
• scanf() ;
• fgets().

Ces trois fonctions extraient un caractère du flux entrant (pour getchar(), ce flux est stdin). C'est insuffisant pour saisir autre chose qu'un simple <ENTER>. Ces fonctions ne sont absolument pas adaptées à la saisie d'un caractère comme un choix de menu par exemple.

Par contre, ces fonctions peuvent être utilisées pour construire des fonctions d'entrées de plus haut niveau plus ou moins spécialisées.

Détails de fonctionnement de fgetc()

Pour des raisons évidentes de sécurité (pas de limitation du nombre de caractères saisis), la fonction gets() ne devrait pas être utilisée. Bien que, à ma connaissance, cette fonction ne soit pas officiellement dépréciée pour des raisons de compatibilité avec le code existant, il est fortement conseillé de ne pas l'utiliser pour de nouveaux développements.

Malgré ce que l'on constate dans l'abondante littérature consacrée à l'initiation au langage C, l'utilisation de scanf() n'est pas adaptée.

En effet, le 'f' de scanf() est là pour nous rappeler que l'entrée doit être formatée (formated), ce qui n'est évidemment pas le cas avec un opérateur humain qui peut entrer n'importe quoi. D'autre part, scanf() gère difficilement le '\n', ce qui entraîne des comportements aberrants dans les saisies si on ne prend pas certaines précautions d'usage.

L'utilisation correcte et sûre de scanf() est complexe, et n'est pas à la portée d'un débutant (ni même à celle de la plupart des programmeurs expérimentés). Néanmoins, il est possible d'utiliser correctement scanf() si on se forme correctement. En lisant par exemple l'article Scanf démythifiée.

Cette fonction est parfaitement adaptée à la saisie d'une ligne, (même de 1 caractère). Son usage est recommandé.

S'il faut saisir une valeur numérique, celle-ci sera d'abord saisie sous forme de ligne, puis traduite par la fonction appropriée (strtol(), strtoul(), strtod()) ou sscanf()) avec le filtre approprié :

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   int ret;
   char temp[20];
 
   do
   {
      char saisie[20];
 
      printf("Entrez un nombre : ");
      fflush (stdout);
 
      fgets (saisie, sizeof saisie, stdin);
 
      /* Filtrage des caractères (entier décimal)
       * Nota : la saisie s'arrête à la première erreur.
       * Ce qui est saisi avant est considéré comme valide.
       *
       * "123a" -> "123" : ret = 1
       *
       * "a123" -> ""    : ret = 0
       */
      ret = sscanf (saisie, "%[0-9-]s", temp);
   }
   while (ret != 1);
 
   {
      long n = strtol (temp, NULL, 10);
 
      printf ("La chaine est '%s', soit %ld\n", temp, n);
   }
   return 0;
}

D'autres exemples dans le chapitre sur les fichiers.

Comment se fabriquer des entrées solides en C

Cette fonction d'apparence simple a en fait un comportement plus complexe qu'il n'y parait. En effet, elle regroupe un certain nombre de comportements non triviaux qui sont rarement expliqués dans la littérature C.

XXXII-G-1. Comportement visible.▲

XXXII-G-2. Comportement interne.▲

XXXII-G-3. Quelques expérimentations.▲

#include <stdio.h>
 
int main (void)
{
 
   int x = fgetc(stdin);
 
   printf ("x = %d ('%c')\n", x, x);
 
   return 0;
}

<enter>
x = 10 ('
')

a<enter>
x = 97 ('a')

a<backspace>b<enter>
x = 98 ('b')

abcd<enter>
x = 97 ('a')

#include <stdio.h>
 
int main (void)
{
   int x;
 
   do
   {
      x = fgetc(stdin);
      printf ("x = %d ('%c')\n", x, x);
   }
   while (1);
 
   return 0;
}

Le langage C n'offre pas, à proprement parler, de gestion de fichiers. Il définit plutôt des flux d'entrées / sorties (I/O streams) sur lesquels il peut agir (ouverture/fermeture, lecture/écriture). L'unité d'information gérée par un flux est le byte.

Certains de ces flux sont connectés à des périphériques permettant par exemple de réaliser une interface entre la machine et l'utilisateur (IHM) en mode texte. Mais la plupart du temps, le nom associé au flux est en fait un 'fichier', c'est-à-dire une sorte de mémoire (disque, flash) accessible en écriture et en lecture par l'intermédiaire du système. L'avantage évident est que les données sont permanentes, même après mise hors tension de la machine.

En conséquence, dans la pratique, les termes flux et fichiers sont souvent confondus.

Le langage C fait la distinction entre les fichiers binaires et les fichiers textes. Cette distinction est historique. Elle dépend en fait du système utilisé. Sur certains systèmes, il n'existe aucune différence physique entre les fichiers textes et les fichiers binaires. Sur d'autres systèmes, il existe une différence. Par souci de portabilité, il est recommandé de respecter cette distinction.

Le choix entre fichier texte ou binaire provient du contenu de ce fichier.

XXXIII-B-1. Fichier texte▲

:----------------:--------------:----------------:
: Système        : Fin de ligne : Fin de fichier :
:----------------:--------------:----------------:
: Unix           :              :                :
: Mac X          : 0x0A LF      : Sans objet     :
: Linux          :              :                :
:----------------:--------------:----------------:
: Mac (non unix) : 0x0D CR      : Sans objet     :
:----------------:--------------:----------------:
: MS-DOS         : 0x0D CR      : 0x1A           :
: Windows        : 0x0A LF      : ^Z             :
: Windows NT     :              :                :
:----------------:--------------:----------------:
: VMS STREAM_CR  : 0x0D CR      : Sans objet     :
:----------------:--------------:----------------:
: VMS STREAM_LF  : 0x0A LF      : Sans objet     :
:----------------:--------------:----------------:
: VMS STREAM_CRLF: 0x0D CR      : Sans objet     :
:                : 0x0A LF      :                :
:----------------:--------------:----------------:

XXXIII-B-2. Fichier binaire▲

XXXIII-B-3. Modes d'ouverture d'un fichier▲

FILE *fopen (char const *filename, char const *mode);

   "r"  : mode texte en lecture
   "w"  : mode texte en écriture (création)
   "a"  : mode texte en écriture (ajout)
 
   "rb" : mode binaire en lecture
   "wb" : mode binaire en écriture (création)
   "ab" : mode binaire en écriture (ajout)

XXXIII-B-4. Lecture d'un fichier▲

Ceci est un simple fichier
texte de 2 lignes.

/* fichier1.c */
#include <stdio.h>
 
int main (void)
{
   /* ouverture du fichier en mode texte */
   FILE *fp = fopen ("data.txt", "r");
 
   /* L'ouverture du fichier est-elle réalisée ? */
   if (fp != NULL)
   {
      /* définition d'un tableau de char destine a recevoir la ligne
       * La taille est arbitraire. Elle doit être cependant adaptée * aux besoins courants.
       * Pour les grandes tailles (disons > 256 char),
       * il est préférable d'utiliser une allocation dynamique.
       */
      char ligne[32];
 
      /* lecture de la première ligne */
      fgets (ligne, sizeof ligne, fp);
 
      /* Affichage de la première ligne */
      printf ("1: %s\n", ligne);
 
      /* lecture de la deuxième ligne */
      fgets (ligne, sizeof ligne, fp);
 
      /* Affichage de la deuxième ligne */
      printf ("2: %s\n", ligne);
 
      /* Fermeture du fichier */
      fclose (fp);
   }
   else
   {
      printf ("Erreur d'ouverture du fichier\n");
   }
   return 0;
}

1: Ceci est un simple fichier
 
2: texte de 2 lignes.

     while (fonction_de_lecture(fp) != ERREUR)
   {
      ...
   }
 
   if (feof(fp))
   {
      /* la fin de fichier a été détectée */
      puts ("EOF");
   }
 
   if (ferror(fp))
   {
      /* une erreur s'est produite */
      perror (NOM_DU_FICHIER);
   }
 
   fclose (fp);

#include <stdio.h>
#include <string.h>
   ...
{
   char ligne[123];
 
   /* test d'erreur omis */
   fgets (ligne, sizeof ligne, fp);
 
   {
      /* chercher le '\n' */
      char *p = strchr(ligne, '\n');
 
      if (p != NULL)
      {
         /* si on l'a trouve, on l'elimine. */
         *p = 0;
      }
      else
      {
         /* Le traitement depend de l'application.
          * Par exemple, ici, on choisit d'ignorer
          * les autres caracteres.
          */
 
         /* sinon, on lit tous les caracteres restants */
         int c;
 
         while ((c = fgetc(fp)) != '\n' && c != EOF)
         {
         }
      }
   }
}

/* fichier2.c */
#include <stdio.h>
 
int main (void)
{
   FILE *fp = fopen ("data.txt", "r");
 
   if (fp != NULL)
   {
      char ligne[32];
 
      /* définition d'un compteur de lignes et initialisation */
      int cpt = 0;
 
      /* lecture des lignes */
      while (fgets (ligne, sizeof ligne, fp) != NULL)
      {
         /* Mise a jour du compteur */
         cpt++;
 
         /* Affichage des lignes */
         printf ("%d: %s\n", cpt, ligne);
      }
 
      /* On peut ajouter ici la détection de la cause
       * de l'erreur décrite ci-dessus
       */
 
      fclose (fp);
   }
   else
   {
      printf ("Erreur d'ouverture du fichier\n");
   }
 
   return 0;
}

<...>
   char ligne[16];
<...>

1: Ceci est un sim
2: ple fichier
 
3: texte de 2 lign
4: es.

0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15 : Indice
'C' 'e' 'c' 'i' ' ' 'e' 's' 't' ' ' 'u' 'n' ' ' 's' 'i' 'm'  0 : Données

0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15 : Indice
'p' 'l' 'e' ' ' 'f' 'i' 'c' 'h' 'i' 'e' 'r' '\n' 0             : Données

XXXIII-B-5. Écriture dans un fichier▲

XXXIII-B-6. Bien utiliser les formats de données▲

Pour supprimer un enregistrement, le plus simple est de procéder ainsi :

• le fichier original est ouvert en lecture. Un nouveau fichier est ouvert en écriture. L'original est lu enregistrement par enregistrement (fread()), et recopié dans le nouveau fichier (fwrite()) en omettant l'enregistrement à supprimer (if …) ;
• par un jeu subtil de suppression et de renommage (remove(), rename()), on se retrouve avec une copie de l'original (genre .old ou .bak) et le nouveau fichier qui a maintenant le nom de l'ancien. L'opération reste simple, et a l'avantage de permettre l'annulation (par renommage de l'ancien fichier).

Toute autre opération basée sur l'écriture/lecture dans le même fichier est dangereuse, non portable et se traduit souvent par la destruction du fichier original sans recours possible.

Il ne faut pas se tromper d'outil. Les flux du C sur disque sont très pratiques pour enregistrer quelques données statiques dans un fichier texte. En binaire, c'est déjà plus risqué à moins de passer par un format indépendant comme XDR. Pour gérer des enregistrements, les fichiers C sont trop rustiques. Il faut une véritable base de données (comme SQLite ouMySQL par exemple).