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 entraine 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� 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 caracteres (entier decimal)
       * Nota : la saisie s'arrete a la premiere erreur.
       * Ce qui est saisi avant est considere 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 realisee ? */
   if (fp != NULL)
   {
      /* definition d'un tableau de char destine a recevoir la ligne
       * La taille est arbitraire. Elle doit etre cependant adaptee * aux besoins courants.
       * Pour les grandes tailles (disons > 256 char),
       * il est preferable d'utiliser une allocation dynamique.
       */
      char ligne[32];
 
      /* lecture de la premiere ligne */
      fgets (ligne, sizeof ligne, fp);
 
      /* Affichage de la premiere ligne */
      printf ("1: %s\n", ligne);
 
      /* lecture de la deuxieme ligne */
      fgets (ligne, sizeof ligne, fp);
 
      /* Affichage de la deuxieme 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 ete detectee */
      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 choisi 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];
 
      /* definition 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 detection de la cause
       * de l'erreur decrite 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 ou MySQL par exemple).