#include "def.h"
#include 
void init(int t[], logical imp)
{
  int i;

  for( i=0; i

Il existe une bibliothèque standard de fichiers en-tête nécessaires lors de l'appel de certaines fonctions :

• stdio.h (entrées-sorties),
• string.h (manipulations de chaînes de caractères),
• ctype.h (test du type d'un caractère : lettre, chiffre, séparateur, ...),
• setjmp.h (sauvegarde et restauration de contexte),
• time.h (manipulation de la date et de l'heure),
• varargs.h (fonction avec un nombre variable d'arguments),

• stdarg.h (fonction avec un nombre variable d'arguments),
• errno.h (codification des erreurs lors d'appels système),
• signal.h (manipulation des signaux inter-processus),
• math.h (manipulation de fonctions mathématiques),
• fcntl.h (définitions concernant les entrées-sorties).

Retour début .

7.5 - Compilation conditionnelle

Test d'existence d'une pseudo-constante

Ce sont les directives #ifdef et #ifndef qui permettent de tester l'existence d'une pseudo-constante.

Syntaxe

    #ifdef identificateur
       partie-alors
    [#else
       partie-sinon]
    #endif

    #ifndef identificateur
       partie-alors
    [#else
       partie-sinon]
    #endif
    

Exemple

      def.h               source.c

  #ifdef TAILLE_BUF
  # undef TAILLE_BUF
  #endif /* TAILLE_BUF */
  #define TAILLE_BUF 4096
  

#ifdef DEBUG            |  #define DEBUG
  #define trace(s) \    |  #include "def.h"
          printf s      |  #include <stdio.h>
#else                   |  main()
#define trace(s)        | {
#endif/* DEBUG */       |     int f(float x);
                        |     int i;
                        |     float r;
                        |
                        |     i = f(r);
                        |     trace(("%d\n", i));
                        |  }
  

Syntaxe

  cc -Dpseudo-constante[=valeur] ...
  

            cc -DDEBUG source.c
  

Évaluation de pseudo-expressions

Il est possible de construire des expressions interprétables par le préprocesseur à l'aide :

• de constantes entières ou caractères,
• de parenthèses,
• des opérateurs unaires -, ! ~,
• des opérateurs binaires +, -, *, /, %, &, |, <<, >>, <, <=, >, >=, ==, !=, && et ||,
• de l'opérateur conditionnel ?:,
• de l'opérateur unaire defined qui s'applique à une pseudo-constante.

Syntaxe

     #if pseudo-expression
        partie-alors
     [#else
        partie-sinon]
     #endif
     

Remarque

Si l'on désire mettre en commentaire une portion de programme, la solution consistant à l'encadrer par les caractères /* et */ ne marche pas si elle contient elle-même des commentaires.

Une solution simple est de placer en tête de la région à commenter la directive #if 0, et à la fin la directive #endif /* 0 */.

Exemple

~~~~~~~~~~~~~~~~~~~~~~source.c

#define TBLOC 256
#if !defined  TAILLE
#  define TAILLE TBLOC
#endif
#if TAILLE%TBLOC == 0
#  define TAILLEMAX TAILLE
#else
#  define TAILLEMAX ((TAILLE/TBLOC+1)*TBLOC)
#endif
static char buffer[TAILLEMAX];
main()
{
   printf( "Taille du vecteur : %d caractères\n",
            sizeof buffer );
}
     

1. cc -DTAILLE=255 source.c
2. cc -DTAILLE=257 source.c
3. cc source.c

Retour début

8 - Les fonctions

• 8.1 - Passage arguments-paramètres
• 8.2 - Fonction retournant un pointeur
• 8.3 - Passage d'un vecteur comme argument
• 8.4 - Passage d'une structure comme argument
• 8.5 - Passage d'une fonction comme argument
• 8.6 - Passage d'arguments à la fonction main
• 8.7 - Fonction avec un nombre variable d'arguments

Retour début .

8.1 - Passage arguments-paramètres

Dans les langages de programmation il existe deux techniques de passage d'arguments :

• par adresse,
• par valeur.

Le langage C a choisi la 2^e solution.

Si un argument doit être passé par adresse, c'est le programmeur qui en prend l'initiative et ceci grâce à l'opérateur d'adressage (&).

Exemple

#include <stdio.h>
void main()
{
   int a, b, c;
   void somme(int a, int b, int *c);

   a = 3;
   b = 8;
   somme(a, b, &c);
   printf("Somme de a et b : %d\n", c);

   return;
}

void somme(int a, int b, int *c)
{
   *c = a + b;

   return;
}
     

Retour début .

8.2 - Fonction retournant un pointeur

Il convient d'être prudent lors de l'utilisation d'une fonction retournant un pointeur. Il faudra éviter l'erreur qui consiste à retourner l'adresse d'une variable temporaire.

Exemple

#include <stdio.h>
void main()
{
   char *p;
   char *ini_car(void);
   p = ini_car();
   printf("%c\n", *p);
}
char *ini_car(void)
{
   char c;
   c = '#';
   return(&c);     <===  ERREUR
}
     

Retour début .

8.3 - Passage d'un vecteur comme argument

Lorsqu'un vecteur est passé en argument, c'est donc l'adresse de son 1^er élément qui est transmise par valeur.

Exemple

#define NbElements(t) sizeof t / sizeof t[0]
#include <stdio.h>
main()
{
   int  tab[] = { 1, 9, 10, 14, 18};
   int  somme(int t[], int n);
   void impression(int *t, int n);
   printf("%d\n", somme(tab, NbElements(tab)));
   impression(tab, NbElements(tab));
}
int  somme(int t[], int n)
{
   int i, som=0;
   for (i=0; i < n; i++) som += t[i];
   return som;
}
void impression(int *t, int n)
{
   int i=0, *p;
   for (p=t; t-p < n; t++)
      printf("t[%d] = %d\n", i++, *t);
}
     

Exemple

#define NbElements(t) sizeof t / sizeof t[0]
#include <stdio.h>
main()
{
   int tab[][5] = {
                     { 4, 7, 1, 9, 6},
                     { 5, 9, 3, 4, 2},
                     { 2, 9, 5, 9, 13}
                  };
   int somme(int (*t)[5], int n);

   printf("Somme des éléments de tab : %d\n",
           somme(tab, NbElements(tab)));
}
int somme(int (*t)[5], int n)
{
   int i, som = 0;
   int (*p)[5] = t;
   for(; t-p < n; t++)
     for (i=0; i < 5; i++)
        som += (*t)[i];
   return som;
}
     

Exemple

#define DIM1 10
#define DIM2  4
#define DIM3  5
main()
{
   int tab[DIM1][DIM2][DIM3];
   void init(int (*t)[DIM3], int n);
   int i, n = DIM2;

   for(i=0; i < DIM1; i++)
     init(tab[i], i);
}
void init(int (*t)[DIM3], int n)
{
   int i, j;

   for(i=0; i < DIM2; i++)
     for(j=0; j < DIM3; j++) {
       t[i][j]      = 2*(i+n*DIM2);
       *(*(t+i)+j) += 1;
     }
}
     

Retour début .

8.4 - Passage d'une structure comme argument

Exemple

#include <stdio.h>
#define NbElts(v) ( sizeof v / sizeof v[0] )

typedef struct
{
   float v[6];
} Vecteur;
     

main()
{
  Vecteur vec = { {1.34f, 8.78f, 10.f,
                   4.f, 22.12f, 3.145f} };
  Vecteur inv;
  Vecteur inverse( Vecteur vecteur, int n );
  int     i, n = NbElts(vec.v);

  inv = inverse( vec, n );
  for( i=0; i < n; i++ )
    printf( "inv.v[%d] : %f\n", i, inv.v[i] );
}

Vecteur inverse( Vecteur vecteur, int n )
{
  Vecteur w;
  int     i;

  for( i=0; i < n; i++ )
    w.v[i] = vecteur.v[i] ? 1./vecteur.v[i] : 0.f;

  return w;
}
     

Retour début .

8.5 - Passage d'une fonction comme argument

Exemple

double integrale(double b_inf, double b_sup,
                 int pas, double (*f)(double));
double carre(double x);
int main()
{
   double b_inf, b_sup, aire;
   int    pas;
   b_inf = 1., b_sup = 6., pas = 2000;
   aire = integrale(b_inf, b_sup, pas, carre);
   printf("Aire : %f\n", aire);

   return 0;
}
double integrale(double b_inf, double b_sup,
                 int pas, double (*f)(double))
{
   double surface = 0., h;
   int    i;
   h = (b_sup - b_inf)/pas;
   for(i=0; i < pas; i++)
     surface += h*(*f)(b_inf+i*h);

   return surface;
}
double carre(double x) {return x*x;}
     

Retour début .

8.6 - Passage d'arguments à la fonction main

Ces arguments sont constitués de :

• ceux fournis au lancement de l'exécutable,
• leur nombre (y compris l'exécutable),
• l'environnement du shell.

Par convention :

• argc désigne le nombre d'arguments transmis au moment du lancement de l'exécutable,
• argv désigne le vecteur contenant les différents arguments,
• envp désigne le vecteur contenant les informations sur l'environnement.

Exemple

La commande a.out toto titi tata génère la structure de données suivante :

Tableau des arguments

Exemple

#include <stdio.h>
main( int argc, char **argv, char **envp )
{
  void usage(char *s);

  if( argc != 3 )
    usage( argv[0] );
  for( ; *argv; argv++ )
    printf( "%s\n", *argv );
  for( ; *envp; envp++ )
    printf( "%s\n", *envp );
}

void usage( char *s )
{
  fprintf( stderr, "usage : %s arg1 arg2\n", s );
  exit(1);
}
     

Retour début .

8.7 - Fonction avec un nombre variable d'arguments

Exemple

int puissance(int n, int x)
{
  int p = 1;
  while(n--) p *= x;
  return p;
}
void main()
{
  int m, k, r;
  k = 4; m = 2;
  r = puissance(k+3, m);
}
    

A l'appel de la fonction puissance de l'exemple précédent il y a :

• allocation dans la pile d'autant de variables consécutives qu'il y a d'arguments spécifiés, (1)
• copie dans ces variables des valeurs des arguments, (2)
• mise en relation des arguments d'appel avec ceux indiqués lors de la définition de la fonction appelée (fonction puissance). (3)

Processus de passage d'arguments

Ce type de passage d'arguments permet d'écrire des fonctions avec un nombre variable d'arguments.

Dans le prototype d'une telle fonction, on indiquera les arguments suivis de :

• ... pour les compilateurs ANSI,
• va_alist pour les compilateurs avant norme.

Comme les arguments sont rangés de façon consécutive dans la pile, le programmeur a la possibilité d'aller chercher les arguments en surnombre.

Exemple

void fonction(int a, ...);
main()
{
   int i = 10, j = 11, k = 12;
   printf("Avant appel fonction i = %d\n", i);
   printf("Avant appel fonction j = %d\n", j);
   printf("Avant appel fonction k = %d\n", k);
   fonction(i, j, k);
}
void fonction(int a, ...)
{
   printf("Valeur de a = %d\n", a);
   printf("Récupération de j = %d\n", *(&a + 1));
   printf("Récupération de k = %d\n", *(&a + 2));
}
     

Pour ce faire, le dernier argument fourni à l'appel de la fonction peut par exemple indiquer le nombre d'arguments en surnombre, ou bien ceux-ci peuvent être suivis par un argument supplémentaire de même type avec une valeur spéciale (valeur sentinelle).

Par contre la norme ne précise pas l'ordre dans lequel les arguments doivent être empilés, cette méthode de la pile n'est donc pas portable.

Pour assurer cette portabilité, chaque système propose des pseudo-constantes et pseudo-fonctions permettant au programmeur de gérer cette recherche.

Version Unix System V

Les pseudo-constantes et pseudo-fonctions sont stockées dans le fichier en-tête varargs.h :

• va_alist symbolise les arguments en surnombre dans le prototype,
• va_list permet de déclarer le pointeur dans la pile,
• va_dcl permet de déclarer le 1^er argument en surnombre,
• va_start permet d'initialiser le pointeur de la pile sur le début de la liste des arguments en surnombre,
• va_arg récupère les valeurs des arguments en surnombre,
• va_end appelée lorsque la recherche est terminée.

Exemple

#include <stdio.h>
#include <varargs.h>
main()
{
   float moyenne();
   printf("moyenne = %f\n", moyenne(4, 1, 2, 3, 4));
   printf("moyenne = %f\n",
           moyenne(5, 1, 2, 3, 4, 5));
}
float moyenne(nombre, va_alist)
int nombre;
va_dcl
{
   int somme = 0, i;
   va_list arg;
   va_start(arg);
   for(i=0; i < nombre; i++)
     somme += va_arg(arg, int);
   va_end(arg);
   return somme/nombre;
}
     

Exemple

#include <stdio.h>
#include <varargs.h>
main()
{
   float moyenne();
   printf("moyenne = %f\n",
           moyenne(4, 1.f, 2.f, 3.f, 4.f));
   printf("moyenne = %f\n",
           moyenne(5, 1.f, 2.f, 3.f, 4.f, 5.f));
}
float moyenne(nombre, va_alist)
int nombre;
va_dcl
{
   float   somme = 0.f;
   int     i;
   va_list arg;
   va_start(arg);
   for(i=0; i < nombre; i++)
     somme += va_arg(arg, double);  ===> surtout
   va_end(arg);                          pas float!
   return somme/nombre;
}
     

Version ANSI

Les pseudo-constantes et pseudo-fonctions sont stockées dans le fichier en-tête stdarg.h :

• va_list permet de déclarer le pointeur dans la pile,
• va_start permet d'initialiser le pointeur de la pile sur le début de la liste des arguments en surnombre,
• va_arg récupère les valeurs des arguments en surnombre,
• va_end appelée lorsque la recherche est terminée.

Exemple

#include <stdio.h>
#include <stdarg.h>
main()
{
   float moyenne(int nombre, ...);
   printf("moyenne = %f\n", moyenne(4, 1, 2, 3, 4));
   printf("moyenne = %f\n",
           moyenne(5, 1, 2, 3, 4, 5));
}
float moyenne(int nombre, ...)
{
   int somme = 0, i;
   va_list arg;
   va_start(arg, nombre);
   for(i=0; i < nombre; i++)
     somme += va_arg(arg, int);
   va_end(arg);
   return somme/nombre;
}
     

9 - La bibliothèque standard

• 9.1 - Notion de pointeur générique
• 9.2 - Entrées-sorties de haut niveau
• 9.3 - Manipulation de caractères
• 9.4 - Fonctions de conversions
• 9.5 - Manipulation de chaînes de caractères
• 9.6 - Allocation dynamique de mémoire
• 9.7 - Date et heure courantes
• 9.8 - Accès à l'environnement
• 9.9 - Sauvegarde et restauration du contexte
• 9.10 - Aide à la mise au point de programme
• 9.12 - Récupération des erreurs
• 9.13 - Fonctions mathématiques
• 9.14 - Fonctions de recherche et de tri

Retour début .

9.1 - Notion de pointeur générique

On ne pourra pas appliquer les opérateurs d'indirection et d'auto-incrémentation, auto-décrémentation à un pointeur générique.

Par contre, si p et q sont deux pointeurs, les affectations :

• p = q;
• q = p;

Exemples

int x[5], i, *k;
float *r;
void  *p;
void  *q;

p = &x[0];       /* correct  */
*p = ...         /* interdit */
q = p + 1;       /* interdit */
r = p;           /* correct  */
p = r;           /* correct  */
p[1] = ...;      /* interdit */
    

Exemples

void echange (void *p, void *q)
{
  void *r;

   r          = *(void **)p;
  *(void **)p = *(void **)q;
  *(void **)q =  r;
}
main()
{
  int    *i1, *i2;
  float  *f1, *f2;
  double *d1, *d2;
      ...
  echange(&i1, &i2);
  echange(&f1, &f2);
  echange(&d1, &d2);
}
    

Retour début .

9.2 - Entrées-sorties de haut niveau

• le formatage des données,
• la mémorisation des données dans une mémoire tampon.

• la nature de l'entrée-sortie,
• la mémoire tampon,
• le fichier sur lequel elle porte,
• la position courante dans le fichier, ...

Cette structure de données est un objet de type FILE. Dans le programme, un flot sera déclaré de type FILE *.
Trois flots sont prédéfinis au lancement d'un processus :

• stdin initialisé en lecture sur l'entrée standard,
• stdout initialisé en écriture sur la sortie standard,
• stderr initialisé en écriture sur la sortie erreur standard.

Les informations précédentes sont contenues dans le fichier en-tête stdio.h. Ce fichier contient, de plus, les déclarations des différentes fonctions d'entrée-sortie, ainsi que la déclaration d'un vecteur (_iob) de type FILE dont la dimension est définie à l'aide d'une pseudo-constante.

Extrait du fichier stdio.h sur IBM/RS6000

#define _NIOBRW         20
extern FILE     _iob[_NIOBRW];

#define stdin           (&_iob[0])
#define stdout          (&_iob[1])
#define stderr          (&_iob[2])
     

Retour début .

9.2.1 - Fonctions d'ouverture et de fermeture

L'acquisition d'un nouveau flot s'effectue par l'appel à la fonction fopen. La fonction fclose permet de le fermer.

Syntaxe

FILE *fopen(const char *file, const char *type);
int   fclose(const FILE *flot);
     

Un pointeur NULL, pseudo-constante définie comme (void *)0 dans stdio.h, indique une fin anormale.

La fonction fclose retourne 0 en cas de succès, -1 sinon.

Le 2^e argument de la fonction fopen indique le mode d'ouverture du fichier.

Accès	Paramètre	Position	Comportement
			si le fichier existe	si le fichier n'existe pas
lecture	r	début	.	erreur
écriture	w a	début fin	mis à zéro	création création
lecture et écriture	r+ w+ a+	début début fin	mis à zéro	erreur création création

Certains systèmes font la distinction entre les fichiers texte et binaire. Pour manipuler ces derniers, il suffit de rajouter le caractère b dans la chaîne indiquant le mode d'ouverture. Sous UNIX, il est ignoré car il n'existe aucune différence entre un fichier binaire et un fichier de données quelconques.

Exemple

#include <stdio.h>
main()
{
  FILE * flot;

  if( (flot = fopen( "donnees", "r" )) == NULL )
  {
    fprintf( stderr, "Erreur à l'ouverture\n" );
    exit(1);
  }
      ...
      ...
  fclose( flot );
}
  

Retour début .

9.2.2 - Lecture et écriture par caractère

Les fonctions getc, fgetc et putc, fputc permettent de lire ou écrire un caractère sur un flot donné.

getc et putc sont des pseudo-fonctions.

Syntaxe

  int getc(FILE *Stream)
  int fgetc(FILE *Stream)
  int putc(int c, FILE *Stream)
  int fputc(int c, FILE *Stream)
  

• getchar() identique à getc(stdin),
• putchar(c) identique à putc(c, stdout).

Ces fonctions retournent soit le caractère traité, soit la pseudo-constante EOF, définie comme -1 dans le fichier stdio.h, en cas d'erreur (fin de fichier par exemple).

Deux pseudo-fonctions feof et ferror, définies dans le fichier stdio.h, permettent de tester, respectivement, la fin de fichier et une éventuelle erreur d'entrée-sortie sur le flot passé en argument.

Dans le cas d'une entrée-sortie au terminal, c'est le retour chariot qui provoque l'envoi au programme de la mémoire tampon rattachée au pilote /dev/tty.

Exemple

#include <stdio.h>
main()
{
  char c;  <=== Attention Erreur !
                ----------------

  while( (c = getchar()) != EOF )
     putchar(c);
}
  

Exemples corrects

#include <stdio.h>
main()
{
  int c;

  while( (c = getchar()) != EOF )
     putchar(c);
}
  

#include <stdio.h>
main()
{
  int c;

  c = getchar();
  while( ! ferror(stdin) &&
         ! feof(stdin) )
  {
     putchar(c);
     c = getchar();
  }
}
  

Retour début .

9.2.3 - Lecture et écriture de mots

Les fonctions getw et putw permettent de lire ou écrire des mots.

Syntaxe

  int getw(FILE *flot)
  int putw(int c, FILE *flot)
  

Exemple

#include <stdio.h>
#define DIM 100
main()
{
   FILE *flot;
   int   tab[DIM];
   int   i;

   if( (flot = fopen( "resultat", "w" )) == NULL )
   {
     perror("fopen");
     exit(1);
   }
   for( i=0; i < DIM; i++ )
   {
     tab[i] = i*i;
     putw( tab[i], flot );
   }
   fclose( flot );
}
  

Retour début .

9.2.4 - Lecture et écriture d'une chaîne de caractères

Les fonctions gets, fgets et puts, fputs permettent de lire et écrire des chaînes de caractères.

Syntaxe

  char *gets(char *string)
  int   puts(char *string)
  char *fgets(char *string, int nombre, FILE *flot)
  int   fputs(char *string, FILE *flot)
  

• gets lit sur le flot stdin jusqu'à la présence du caractère retour chariot et range le résultat dans la chaîne passée en argument. Le retour chariot est remplacé par le caractère \0 de fin de chaîne.

• puts écrit sur le flot stdout la chaîne passée en argument suivie d'un retour chariot.
• fgets lit sur le flot fourni en 3^e argument jusqu'à ce que l'un des évènements suivants se produise :
  • «~nombre-1~» octets ont été lus,
  • rencontre d'un retour chariot,
  • fin de fichier atteinte.
  Le caractère \0 est ensuite ajouté en fin de chaîne. Dans le deuxième cas le retour chariot est stocké dans la chaîne.
• fputs écrit la chaîne fournie en 1^er argument sur le flot spécifié en 2^e argument. Cette fonction n'ajoute pas de retour chariot.

Exemple

#include <stdio.h>
main()
{
  char *mus1 = "Wolfgang Amadeus Mozart\n";
  char *mus2 = "Ludwig van Beethoven\n";
  char  buffer[BUFSIZ+1];
  FILE *f;
  if( (f = fopen( "musiciens", "w" )) == NULL )
  {
    perror( "fopen" );
    exit(1);
  }
  fputs( mus1, f ); fputs( mus2, f );
  fclose(f);
  if( (f = fopen( "musiciens", "r" )) == NULL )
  {
    perror( "fopen" );
    exit(2);
  }
  while( fgets( buffer, sizeof(buffer), f ) )
     fputs( buffer, stdout );
  fclose(f);
  puts( "\nExecution terminée." );
}
  

Retour début .

9.2.5 - Lecture et écriture de blocs

Les fonctions fread et fwrite permettent de lire et d'écrire des blocs de données tels des structures ou des tableaux.

Syntaxe

size_t fread(void *p, size_t t, size_t n, FILE *f)
size_t fwrite(void *p, size_t t, size_t n, FILE *f)
  

• p désigne la mémoire tampon réceptrice ou émettrice,
• t indique la taille du bloc à lire ou écrire,
• n indique le nombre de blocs à lire ou écrire,
• f désigne le flot.

Exemple

#include <stdio.h>
#define NbElt(t) ( sizeof t / sizeof t[0] )
main() {
  typedef struct { int   n; float t[10]; char  c;
                 } Donnee;
  Donnee s1   = { 1, { 1.,  2., 3.}, 'a'};
  Donnee s2[] = { {4, {10., 32., 3.}, 'z'},
                  {5, { 2., 11., 2., 4.}, 'h'} };
  FILE *f, *f_sauve; Donnee s;
  if( (f = fopen( "donnee", "w" )) == NULL )
    perror("fopen"), exit(1);
  fwrite( &s1, sizeof(Donnee), 1, f );
  fwrite(  s2, sizeof(Donnee), NbElt(s2), f );
  fclose(f);
  if( (f       = fopen( "donnee", "r" ))     == NULL ||
      (f_sauve = fopen( "sauvegarde", "w" )) == NULL )
    perror("fopen"), exit(2);
  fread( &s, sizeof(Donnee), 1, f );
  while( ! feof(f) )
  {
    fwrite( &s, sizeof(Donnee), 1, f_sauve );
    fread( &s, sizeof(Donnee), 1, f );
  }
  fclose(f); fclose(f_sauve);
}
  

Retour début .

9.2.6 - Accès direct

Par défaut, les fonctions précédentes travaillent en mode séquentiel. Chaque lecture ou écriture s'effectue à partir d'une position courante, et incrémente cette position du nombre de caractères lus ou écrits.

Les fonctions fseek et ftell permettent, respectivement, de modifier et récupérer la position courante.

int  fseek(FILE *f, long decalage, int position);
long ftell(FILE *f);
    

La fonction ftell retourne la position courante en octets.

La fonction fseek permet de la modifier :

• la valeur du décalage est exprimée en octets,
• la position est celle à partir de laquelle est calculé le décalage. Elle s'exprime à l'aide de 3 pseudo-constantes définies dans le fichier stdio.h :
  • SEEK_SET (0 : début de fichier),
  • SEEK_CUR (1 : position courante),
  • SEEK_END (2 : fin de fichier).

Exemple

#include <stdio.h>
main( int argc, char **argv )
{
  FILE *f;
  void  usage( char *s );

  if( argc != 2 )
    usage( argv[0] );
  if( (f = fopen( argv[1], "r" )) == NULL )
  {
    perror( "fopen" );
    exit(2);
  }
  fseek( f, 0L, SEEK_END );
  printf( "Taille(octets) : %d\n", ftell(f) );
  fclose(f);
}

void usage(char *s)
{
  fprintf( stderr, "usage : %s fichier\n", s );
  exit(1);
}
     

Exemple

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>

main( int argc, char **argv )
{
  void  conversion( char *nom, char *mode );
  FILE *f;
  char  nom[100];
  char *mus[] = { "Frédéric Chopin\n",
                  "Maurice Ravel\n", };
  int   n;

  if ( argc != 2 ) exit( 1 );
  if ( ( f = fopen( argv[1], "r+" ) ) == NULL )
  {
    if ( errno != ENOENT ||
       ( f = fopen( argv[1], "w+" ) ) == NULL )
    {
      perror( "fopen" );
      exit( 2 );
    }
  }
     

  fgets( nom, 100, f );
  while ( !feof( f ) )
  {
    fseek( f, -1L*strlen(nom), SEEK_CUR );
    conversion( nom, "majuscule" );
    fputs( nom, f );
    fseek( f, 0L, SEEK_CUR );
    fgets( nom, 100, f );
  }
  for( n=0; n < sizeof mus / sizeof mus[0]; n++ )
    fputs( mus[n], f );
  fclose( f );
}
void conversion( char *nom, char *mode )
{
  char  *ptr;
  int  (*conv)(int);

  if ( !strcmp( mode, "majuscule" ) )
    conv = toupper;
  else if ( !strcmp( mode, "minuscule" ) )
    conv = tolower;
  for( ptr=nom; *ptr++=conv(*ptr); )
     ;
  return;
}
     

Retour début .

9.2.7 - Entrées-sorties formatées

Les fonctions scanf, fscanf, sscanf et printf, fprintf, sprintf permettent d'effectuer des entrées-sorties de données avec conversions.

Syntaxe

int scanf(const char *format [, ...])
int fscanf(FILE *f, const char *format [, ...])
int sscanf(const char *buffer,
           const char *format [, ...])
int printf(const char *format [, ...])
int fprintf(FILE *f, const char *format [, ...])
int sprintf(char *buffer,
            const char *format [, ...])
  

Fonctions printf, fprintf, sprintf

Le paramètre format désigne une chaîne de caractères comprenant :

• des caractères ordinaires,
• des spécifications de conversions : suite de caractères précédée du symbole %.

• sur le flot stdout si printf,
• sur le flot indiqué si fprintf,
• dans la mémoire tampon spécifiée si sprintf.

Une spécification de conversion est constituée du caractère %, suivie dans l'ordre :

• du caractère - qui cadre l'argument converti à gauche dans la zone réceptrice (optionnel),
• d'un caractère de gestion du signe pour les données numériques (optionnel) :
  • + pour forcer la présence du signe,
  • espace pour placer un espace à la place du signe lorsque la donnée est positive.
• du caractère 0 qui, pour les données numériques, remplit, la zone réceptrice, à gauche par des 0 (optionnel),

• du caractère # (optionnel) qui permet :
  • de préfixer par un 0 les nombres entiers écrits en octal,
  • de préfixer par 0x les nombres entiers écrits en hexadécimal,
  • de forcer la présence du point décimal pour les réels.
• de la taille minimum de la zone réceptrice (optionnelle),
• de la précision numérique précédée d'un . (optionnelle) :
  • le nombre de chiffres à droite du point décimal pour un réel (6 par défaut),
  • le nombre maximum de caractères d'une chaîne que l'on veut stocker dans la zone réceptrice,
  • le nombre minimum de chiffres d'un entier que l'on désire voir apparaître dans la zone réceptrice.

• du type de la donnée à écrire, défini par l'un des caractères suivants (obligatoire) :
  • c pour un caractère,
  • u pour un entier non signé,
  • d pour un entier signé sous forme décimale,
  • o pour un entier signé sous forme octale,
  • x pour un entier signé sous forme hexadécimale,
  • f pour un réel sous forme décimale,
  • e pour un réel sous forme exponentielle,
  • g pour un réel sous forme générale :
    • équivalent à e si l'exposant est inférieur à -4 ou supérieur ou égal à la précision,
    • équivalent à f sinon.
    Dans ce cas, la précision indique le nombre maximun de chiffres significatifs.
  • s pour une chaîne de caractères.

Exemples

printf("|%d|\n", 1234);             |1234|
printf("|%-d|\n", 1234);            |1234|
printf("|%+d|\n", 1234);            |+1234|
printf("|% d|\n", 1234);            | 1234|
printf("|%10d|\n", 1234);           |      1234|
printf("|%10.6d|\n", 1234);         |    001234|
printf("|%10.2d|\n", 1234);         |      1234|
printf("|%.6d|\n", 1234);           |001234|
printf("|%06d|\n", 1234);           |001234|
printf("|%.2d|\n", 1234);           |1234|
printf("|%*.6d|\n", 10, 1234);      |    001234|
printf("|%*.*d|\n", 10, 6, 1234);   |    001234|
printf("|%x|\n", 0x56ab);           |56ab|
printf("|%#x|\n", 0x56ab);          |0x56ab|
printf("|%X|\n", 0x56ab);           |56AB|
printf("|%#X|\n", 0x56ab);          |0X56AB|
  

printf("|%f|\n",1.234567890123456789e5);
               |123456.789012|
printf("|%.4f|\n",1.234567890123456789e5);
               |123456.7890|
printf("|%.15f|\n",1.234567890123456789e5);
               |123456.789012345670000|
printf("|%15.4f|\n",1.234567890123456789e5);
               |    123456.7890|

printf("|%e|\n",1.234567890123456789e5);
               |1.234568e+05|
printf("|%.4e|\n",1.234567890123456789e5);
               |1.2346e+05|
printf("|%.18e|\n",1.234567890123456789e5);
               |1.234567890123456700e+05|
printf("|%18.4e|\n",1.234567890123456789e5);
               |        1.2346e+05|
printf("|%.4g|\n",1.234567890123456789e-5);
               |1.235e-05|
printf("|%.4g|\n",1.234567890123456789e+5);
               |1.235e+05|
printf("|%.4g|\n",1.234567890123456789e-3);
               |0.001235|
printf("|%.8g|\n",1.234567890123456789e5);
               |123456.79|
  

#include <stdio.h>
main()
{
  char *chaine = "Wolfgang Amadeus Mozart";

  printf("|%s|\n", chaine);       ===> 1)
  printf("|%.16s|\n", chaine);    ===> 2)
  printf("|%-23.16s|\n", chaine); ===> 3)
  printf("|%23.16s|\n", chaine);  ===> 4)
}

  1) |Wolfgang Amadeus Mozart|

  2) |Wolfgang Amadeus|

  3) |Wolfgang Amadeus       |

  4) |       Wolfgang Amadeus|

  

Fonctions scanf, fscanf, sscanf

Ces fonctions permettent d'effectuer des entrées formatées. Les données lues sont converties suivant les spécifications de conversions indiquées dans la chaîne format, puis stockées dans les arguments successifs fournis à sa suite. Ces arguments doivent être des pointeurs.

La valeur retournée correspond au nombre d'arguments correctement affectés. La chaîne format peut contenir :

• des espaces ou des caractères de tabulation qui seront ignorés,
• des caractères ordinaires qui s'identifieront à ceux de l'entrée,
• des spécifications de conversions.

Chaque champ est défini comme une chaîne de caractères qui s'étend soit :

• jusqu'à la rencontre d'un caractère d'espacement («~espace~», «~tabulation~», «~fin de ligne~»),
• jusqu'à ce que la largeur du champ soit atteinte, dans le cas où celle-ci a été précisée.

Une spécification de conversion est constituée du caractère % suivi dans l'ordre :

• du signe * pour supprimer l'affectation de l'argument correspondant (optionnel),
• d'un nombre indiquant la largeur maximum du champ (optionnel),
• du type de la donnée à lire défini par l'un des caractères suivants :
  • d pour un entier sous forme décimale,
  • i pour un entier. Il peut être sous forme octale (précédé par 0) ou hexadécimale (précédé par 0x ou 0X),
  • o pour un entier sous forme octale (précédé ou non par 0),
  • x pour un entier sous forme hexadécimale (précédé ou non par 0x ou 0X),
  • u pour un entier non signé sous forme décimale,
  • c pour un caractère. Il est à noter que dans ce cas il n'y a plus de notion de caractère d'espacement. Le prochain caractère est lu même s'il s'agit d'un caractère d'espacement. Si l'on veut récupérer le prochain caractère différent d'un caractère d'espacement il faut utiliser la spécification \%1s.
  • s pour une chaîne de caractères. La lecture continue jusqu'au prochain caractère d'espacement ou jusqu'à ce que la largeur du champ ait été atteinte. Le caractère \0 est ensuite ajouté en fin de chaîne,
  • e, f, g pour une constante réelle.
  • [...] pour une chaîne de caractères. Comme dans le cas de c, il n'y a plus de notion de caractère d'espacement. Entre «~crochets~» apparaît une suite de caractères précédée ou non du caractère ^. La lecture s'effectue :
    • jusqu'au caractère différent de ceux indiqués entre «~crochets~» si ceux-ci ne sont pas précédés du caractère ^,
    • tant que le caractère lu est différent de ceux indiqués entre «~crochets~» si ceux-ci sont précédés du caractère ^.
    Le caractère \0 est ensuite ajouté en fin de chaîne.

Remarques

Les arguments correspondant aux spécifications :

• d, i, o, x, u doivent être de type int *,
• e, f, g doivent être de type float *,
• c, s doivent être de type char *.

De même les spécifications e, f, g peuvent être précédées de la lettre l pour référencer un double *.

Exemples

#include <stdio.h>
main()
{
  int   i;
  float x, y;
  char  buffer[BUFSIZ];
  char *p = "12/11/94";
  int   jour, mois, annee;

  scanf( "%d%f%f%*c", &i, &x, &y );
  printf( "i = %d, x = %f, y = %f\n", i, x, y );
  scanf( "%[^\n]%*c", buffer );
  while( ! feof(stdin) )
  {
    fprintf( stderr, "%s\n", buffer );
    scanf( "%[^\n]%*c", buffer );
  }
  sscanf( p, "%d/%d/%d", &jour, &mois, &annee );
  printf( "jour  : %d\n", jour );
  printf( "mois  : %d\n", mois );
  printf( "annee : %d\n", annee );
}
  

#include <stdio.h>
main()
{
  char   mois[10], buffer[BUFSIZ];
  int    quantite;
  double prix;
  FILE  *f;
  if( (f = fopen( "donnees", "r" )) == NULL )
    perror( "fopen" ), exit(1);
  fgets( buffer, sizeof(buffer), f );
  while( ! feof(f) )
  {
    sscanf( buffer, "%s%d%lf",
             mois, &quantite, &prix );
    printf( "mois : %s, qte : %d, prix : %f\n",
             mois, quantite, prix );
    fgets( buffer, sizeof(buffer), f );
  }
  fseek( f, 0L, SEEK_SET );
  fscanf( f, "%s%d%lf", mois, &quantite, &prix );
  while( ! feof(f) )
  {
    printf( "mois : %s, qte : %d, prix : %f\n",
             mois, quantite, prix );
    fscanf( f, "%s%d%lf", mois, &quantite, &prix );
  }
  fclose(f);
}
  

Retour début .

9.2.8 - Autres fonctions

La fonction freopen permet de redéfinir un flot déjà initialisé. Elle est principalement utilisée avec les flots stdin, stdout, stderr, ce qui correspond à une redirection d'entrées-sorties.

La fonction fflush permet de forcer le vidage de la mémoire tampon associée à un flot en sortie. Sur un flot en entrée l'effet est imprévisible.

Syntaxe

FILE *freopen(char *fichier, char *mode, FILE *flot);
int   fflush(FILE *flot);
    

Exemple

#include <stdio.h>
main( int argc, char **argv )
{
  void usage( char *s );

  if( argc != 2 )
    usage( argv[0] );
  if( freopen( argv[1], "w", stdout ) == NULL )
  {
    perror( "freopen" );
    exit(2);
  }
  printf( "Ce message est redirigé  ");
  printf( "dans le fichier  ");
  printf( "dont le nom est  ");
  printf( "passé en argument.\n ");
}

void usage(char *s)
{
  fprintf(stderr, "usage : %s fichier\n", s);
  exit(1);
}
    

Retour début .

9.3 - Manipulation de caractères

• isalnum caractère alphanumérique,
• isalpha caractère alphabétique,
• iscntrl caractère de contrôle,
• isdigit caractère numérique,
• isgraph caractère imprimable sauf l'espace,
• islower caractère minuscule,
• isupper caractère majuscule,
• isprint caractère imprimable y compris l'espace,

• ispunct caractère imprimable différent de l'espace, des lettres et des chiffres,
• isspace espace, saut de page, fin de ligne, retour chariot, tabulation,
• isxdigit chiffre hexadécimal.

Il existe, de plus, deux fonctions permettant de convertir les majuscules en minuscules et réciproquement :

• tolower convertit en minuscule le caractère passé en argument,
• toupper convertit en majuscule le caractère passé en argument.

Exemple

#include <stdio.h>
#include <ctype.h>
main()
{
  int c;
  int NbMaj = 0;
  int NbMin = 0;
  int NbNum = 0;
  int NbAutres = 0;
  while( (c=getchar()) != EOF )
    if( isupper(c) )
      NbMaj++;
    else if( islower(c) )
      NbMin++;
    else if( isdigit(c) )
      NbNum++;
    else
      NbAutres++;
  printf( "NbMaj    : %d\n", NbMaj );
  printf( "NbMin    : %d\n", NbMin );
  printf( "NbNum    : %d\n", NbNum );
  printf( "NbAutres : %d\n", NbAutres );
}
     

Retour début .

9.4 - Fonctions de conversions

• double atof(const char *s) convertit l'argument s en un double,
• int atoi(const char *s) convertit l'argument s en un int,
• long atol(const char *s) convertit l'argument s en un long,

• double strtod(const char *s, char **endp) convertit le début de l'argument s en un double, en ignorant les éventuels caractères d'espacement situés en-tête. Elle place dans l'argument endp l'adresse de la partie non convertie de s, si elle existe, sauf si endp vaut NULL. Si la valeur convertie est trop grande, la fonction retourne la pseudo-constante HUGE_VAL définie dans le fichier en-tête math.h, si elle est trop petite la valeur retournée est 0,

• long strtol(const char *s, char **endp, int base) convertit le début de l'argument s en un long avec un traitement analogue à strtod. L'argument base permet d'indiquer la base (comprise entre 2 et 36) dans laquelle le nombre à convertir est écrit. Si base vaut 0, la base considérée est 8, 10 ou 16 :
  • un 0 en tête indique le format octal,
  • les caractères 0x ou 0X en tête indique le format hexadécimal.
  Si la valeur retournée est trop grande, la fonction retourne les pseudo-constantes LONG_MAX ou LONG_MIN suivant le signe du résultat,
• unsigned long strtoul(const char *s, char **endp, int base)
  est équivalente à strtol mis à part que le résultat est de type unsigned long, et que la valeur de retour, en cas d'erreur, est la pseudo-constante ULONG_MAX définie dans le fichier en-tête limits.h.

Exemple

#include <stdio.h>
#include <stdlib.h>
main()
{
  char *s = "     37.657a54";
  char *cerr;

  printf( "%f\n", strtod( s, &cerr ) );    ===> 37.657
  if( *cerr != '\0' )
    fprintf(  stderr,
             "Caractère erroné : %c\n", *cerr );
  s = "11001110101110";
  printf( "%ld\n", strtol( s, NULL, 2 ) ); ===> 13230
  s = "0x7fff";
  printf( "%ld\n", strtol( s, NULL, 0 ) ); ===> 32767
  s = "0777";
  printf( "%ld\n", strtol( s, NULL, 0 ) ); ===>   511
  s = "777";
  printf( "%ld\n", strtol( s, NULL, 0 ) ); ===>   777
}
     

Retour début .

9.5 - Manipulation de chaînes de caractères

• char *strcpy(char *s1, const char *s2) copie la chaîne s2, y compris le caractère \0, dans la chaîne s1. Elle retourne la chaîne s1,
• char *strncpy(char *s1, const char *s2, int n) copie au plus n caractères de la chaîne s2 dans la chaîne s1 laquelle est complétée par des \0 dans le cas où la chaîne s2 contient moins de n caractères. Cette fonction retourne la chaîne s1,
• char *strdup(char *s) retourne un pointeur sur une zone allouée dynamiquement contenant la duplication de l'argument s,

• char *strcat(char *s1, const char *s2) concatène la chaîne s2 à la chaîne s1. Cette fonction retourne la chaîne s1,
• char *strncat(char *s1, const char *s2, int n) concatène au plus n caractères de la chaîne s2 à la chaîne s1 qui est ensuite terminée par \0. Cette fonction retourne la chaîne s1.

• int strcmp(const char *s1, const char *s2) compare la chaîne s1 à la chaîne s2. Les chaînes sont comparées caractère par caractère en partant de la gauche. Cette fonction retourne :
  • une valeur négative dès qu'un caractère de la chaîne s1 est plus petit que celui de la chaîne s2,
  • une valeur positive dès qu'un caractère de la chaîne s1 est plus grand que celui de la chaîne s2,
  • 0 si les deux chaînes sont identiques.
• int strncmp(const char *s1, const char *s2, int n) compare au plus n caractères de la chaîne s1 à la chaîne s2. La valeur retournée par cette fonction est identique à celle retournée par la fonction strcmp,

• char *strchr(const char *s, int c) retourne un pointeur sur la première occurrence du caractère c dans la chaîne s, ou NULL si c ne figure pas dans s,
• char *strrchr(const char *s, int c) retourne un pointeur sur la dernière occurrence du caractère c dans la chaîne s, ou NULL si c ne figure pas dans s,
• char *strstr(const char *s1, const char *s2) retourne un pointeur sur la première occurrence de la chaîne s2 dans la chaîne s1, ou NULL si elle n'y figure pas.
• size_t strlen(const char *s) retourne la longueur de la chaîne s.

Exemple

#include <stdio.h>
#include <string.h>
main( int argc, char **argv )
{
  char *parm1, *parm2, buffer[BUFSIZ];
  if( argc != 3 ) usage( argv[0] );
  parm1 = strdup( argv[1] );
  parm2 = strdup( argv[2] );
  strcat( strcpy( buffer, "Résultat de la "
                          "concaténation : " ),
          parm1 );
  strcat( strcat( buffer, parm2 ), "\n" );
  printf( "%s", buffer );
  sprintf( buffer, "%s%s%s\n", "Résultat de la "
                               "concaténation : ",
                                parm1, parm2 );
  printf( "%s", buffer );
  free( parm1 ); free( parm2 );
}
void usage( char *s )
{
  fprintf( stderr, "usage : %s ch1 ch2.\n", s );
  exit(1);
}
      

Exemple

#include <stdio.h>
#include <string.h>
main( int argc, char **argv )
{
  void  usage( char *s );
  char *s  = "/usr/include/string.h", *p;
  int   NbSlash = 0;

  if( argc != 3 ) usage( argv[0] );
  if( ! strcmp( argv[1], argv[2] ) )
    printf( "Les 2 arguments sont identiques.\n" );
  else if( strcmp( argv[1], argv[2] ) > 0 )
    printf( "arg1 > arg2\n" );
  else printf( "arg1 < arg2\n" );
  for( p = s-1; p = strchr( ++p, '/' ); NbSlash++ )
              ;
  printf( "La chaîne s contient %d\n", NbSlash );
  printf( "slashs sur %d caractères.\n", strlen(s) );
}
void usage( char *s )
{
  fprintf( stderr, "usage : %s ch1 ch2.\n", s );
  exit(1);
}
      

Il existe d'autres fonctions qui agissent sur des tableaux de caractères plutôt que des chaînes de caractères :

• void *memcpy(void *m1, void *m2, size_t n) copie n caractères de la zone mémoire m2 dans la zone mémoire m1 et retourne m1,
• void *memmove(void *m1, void *m2, size_t n) est identique à memcpy mais fonctionne également dans le cas où les zones mémoires m1 et m2 se chevauchent,

• int memcmp(void *m1, void *m2, size_t n) compare les n premiers caractères des zones mémoires m1 et m2. La valeur de retour se détermine comme pour strcmp,
• void *memchr(void *m, int c, size_t n) retourne un pointeur sur la première occurrence du caractère c dans la zone mémoire m, ou {NULL si c n'y figure pas,
• void *memset(void *m, int c, size_t n) remplit les n premiers caractères de la zone mémoire m avec le caractère c et retourne m.

Exemple

#include <stdio.h>
#include <string.h>
main()
{
  char  buffer[100];
  char  tab[] = "Voici\0une chaîne qui"
                "\0\0contient\0des"
                "\0caractères \"null\".";
  char *p, *ptr;
  int   taille = sizeof tab / sizeof tab[0];
  int   n;

  memset( buffer, ' ', 100 );
  memcpy( buffer, tab, taille );
  n = --taille;
  for( p=ptr=tab; p=memchr( ptr, '\0', n ); )
  {
    *p = ' ';
    n -= p - ptr + 1;
    ptr = ++p;
  }
  printf( "%s\n", buffer );
  printf( "%.*s\n", taille, tab );
}
      

Retour début .

9.6 - Allocation dynamique de mémoire

• malloc et calloc pour allouer un bloc mémoire (initialisé avec des zéros si calloc),
• realloc pour étendre sa taille,
• free pour le libérer.

Syntaxe

void  *malloc(size_t nb_octets)

void  *calloc(size_t nb_elements, size_t taille_elt)

void  *realloc(void *pointeur, size_t nb_octets)

void   free(void *pointeur)
     

Exemple

#include <stdio.h>
#include <stdlib.h>
typedef struct { int nb; float *ptr; } TAB_REEL;
#define TAILLE 100
main()
{
  TAB_REEL *p; int i;
  p = (TAB_REEL *)calloc( TAILLE, sizeof(TAB_REEL) );
  if( ! p )
  {
    fprintf( stderr, "Erreur à l'allocation\n\n" );
    exit(1);
  }
  for( i=0; i < TAILLE; i++ )
  {
    p[i].nb  = TAILLE;
    p[i].ptr = (float *)malloc( p[i].nb*
                                sizeof(float) );
    p[i].ptr[i] = 3.14159f;
  }
  for( i=0; i < TAILLE; i++ ) free( p[i].ptr );
  free( p );
}
     

Exemple

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{
  char **ptr = (char **)NULL;
  char   buffer[BUFSIZ];
  int    nb = 0, i;
  for( ;; )
  {
    printf( "Entrer une chaîne : " );
    scanf( "%s", buffer );
    if( ! strcmp( buffer, "fin" ) ) break;
    ptr = (char **)realloc( ptr,
                            ++nb*sizeof(char *) );
    ptr[nb-1] = (char *)malloc(
                (strlen(buffer)+1)*sizeof(char) );
    strcpy( ptr[nb-1], buffer );
  }
  for( i=0; i < nb; i++ )
  {
    printf( "%s\n", ptr[i] ); free( ptr[i] );
  }
  free( ptr );
}
     

Retour début .

9.7 - Date et heure courantes

• clock_t clock(void) retourne le temps {CPU (en microsecondes) consommé depuis le premier appel à clock. Une division par la pseudo-constante {CLOCKS_PER_SEC permet d'obtenir le temps en secondes,
• time_t time(time_t *t) retourne le temps en secondes écoulé depuis le 1^er janvier 1970 00:00:00 GMT. Si t est différent de {NULL, *t reçoit également cette valeur,
• time_t mktime(struct tm *t) convertit la date et l'heure décrites par la structure pointée par t, en nombre de secondes écoulées depuis le 1^er janvier 1970 00:00:00 GMT, lequel est retourné par la fonction (ou -1 si impossibilité),

• char *asctime(const struct tm *t) convertit la date et l'heure décrites par la structure pointée par t en une chaîne de caractères de la forme : "Thu Oct 19 16:45:02 1995\n",
• struct tm *localtime(const time_t *t) convertit un temps exprimé en secondes écoulées depuis le 1^er janvier 1970 00:00:00 GMT, sous forme date et heure décrites par une structure de type struct tm. Cette fonction retourne un pointeur sur cette structure.
• char *ctime(const time_t *t) convertit un temps exprimé en secondes écoulées depuis le 1^er janvier 1970 00:00:00 GMT, en une chaîne de caractères de la même forme que la fonction asctime. Cette fonction équivaut à : asctime(localtime(t)),

Les types time_t et clock_t sont, respectivement, des alias de long et int.

La structure struct tm, explicitant la date et l'heure, contient les champs suivant (de type int) :

• tm_year : année,
• tm_mon : mois (0-11),
• tm_wday : jour (0-6),
• tm_mday : jour du mois,
• tm_yday : jour de l'année, (0-365),
• tm_hour : heures,
• tm_min : minutes,
• tm_sec : secondes.

Exemple

#include <stdio.h>
#include <time.h>
main()
{
  time_t t;
  struct tm *tm;

  time( &t );
  puts( ctime( &t ) );   /* Thu Feb 27 11:26:36 1997 */
  tm = localtime( &t );
  puts( asctime( tm ) ); /* Thu Feb 27 11:26:36 1997 */
  tm->tm_year = 94;
  tm->tm_mday = 16;
  tm->tm_mon  = 10;
  t = mktime( tm );
  puts( ctime( &t ) );   /* Wed Nov 16 11:26:36 1994 */
  t -= 20*86400;
  puts( ctime( &t ) );   /* Thu Oct 27 11:26:36 1994 */

  return 0;
}
      

Retour début .

9.8 - Accès à l'environnement

Syntaxe

    char *getenv(char *nom)
    

Exemple

#include <stdio.h>
#include <stdlib.h>
#define RACINE        "RACINE"
#define DEFAUT_RACINE "."
main()
{
  char *racine;
  if( (racine = getenv( RACINE )) == NULL )
    racine = DEFAUT_RACINE;
  printf( "Répertoire de travail: \"%s\"\n", racine );

  return 0;
}
    

Retour début .

9.9 - Sauvegarde et restauration du contexte

Sauvegarder le contexte d'un processus, consiste à sauvegarder la valeur des registres à cet instant (notamment la valeur du compteur ordinal ou registre d'instruction qui contient l'adresse de la prochaine instruction machine à exécuter).

Les fonctions setjmp et longjmp permettent, respectivement, de sauvegarder et restaurer le contexte d'un processus. Leurs déclarations se trouvent dans le fichier en-tête setjmp.h.

Syntaxe

    int  setjmp(jmp_buf cntx)
    void longjmp(jmp_buf cntx, int valeur)
    

La restauration de ce contexte est effectuée par la fonction longjmp à laquelle on passe en argument le contexte sauvegardé. L'appel de cette fonction provoque alors une reprise de l'exécution de la fonction setjmp, qui a servi à sauvegarder le contexte, laquelle retourne cette fois-ci l'entier transmis, comme 2^e argument, à la fonction longjmp.

Exemple

#include <stdio.h>
#include <setjmp.h>
jmp_buf cntx;
main()
{
  int appel_boucle();

  printf( "Terminaison avec \"%c\"\n",
           appel_boucle() );

  return 0;
}
int appel_boucle( void )
{
  void boucle( void );
  int  retour = setjmp( cntx );

  printf( "setjmp retourne %d\n", retour );
  if( retour == 0 ) boucle();

  return retour;
}
    

Exemple (suite)

void boucle( void )
{
  for( ;; )
  {
    char getcmd( char * );
    char c = getcmd( "-> " );

    switch( c )
    {
      case 'q':
        longjmp( cntx, c );
      default:
        printf( "Traitement de %c\n", c );
      break;
    }
  }
}
char getcmd( char *s )
{
  char c = (printf( "%s", s ), getchar());
  while( getchar() != '\n' )
      ;
  return c;
}
    

Retour début .

9.10 - Aide à la mise au point de programme

Certains compilateurs provoquent de plus l'arrêt du programme avec création d'un fichier «~image mémoire~» (core). Ce mécanisme peut être désactivé en compilant le programme avec l'option -DNDEBUG.

Exemple

#include <string.h>
#include <assert.h>
#define DIM 50
main()
{
  char tab[DIM];
  void f( char *p, int n );

  memset( tab, ' ', DIM );
  f( tab, DIM+1 );
}

void f( char *p, int n )
{
  char *ptr = p;
  int   i;

  for( i=0; i < n; i++ )
  {
    assert( ptr - p < DIM );
    *ptr++ = '$';
  }
}
    

Retour début .

9.11 - Récupération des erreurs

La fonction perror, dont la déclaration figure dans le fichier en-tête stdio.h, permet d'émettre le message correspondant à la valeur positionnée dans la variable errno.

De plus, la fonction strerror, déclarée dans le fichier en-tête string.h, retourne un pointeur sur ce message.

Syntaxe

    void  perror(const char *s)
    char *strerror(int erreur)
    

La fonction perror émet, sur le flot stderr, le message d'erreur précédé de la chaîne passée en argument ainsi que du caractère :.

La fonction strerror retourne un pointeur sur le message d'erreur dont le numéro est passé en argument.

Exemple

#include <stdio.h>
#include <errno.h>
#include <string.h>
main()
{
  FILE *f;

  if( (f = fopen( "ExistePas", "r" )) == NULL )
  {
    perror( "fopen" );
    puts( strerror( errno ) );
    exit(1);
  }
     ...
  return 0;
}
    

Retour début .

9.12 - Fonctions mathématiques

• sin(x) : sinus de x,
• cos(x) : cosinus de x,
• tan(x) : tangente de x,
• asin(x) : arc sinus de x,
• acos(x) : arc cosinus de x,
• atan(x) : arc tangente de x,
• sinh(x) : sinus hyperbolique de x,
• cosh(x) : cosinus hyperbolique de x,
• tanh(x) : tangente hyperbolique de x,

• exp(x) : exponentielle de x (e^x),
• log(x) : logarithme népérien de x (ln(x)),
• log10(x) : logarithme décimal de x (log₁₀(x)),
• pow(x, y) : x^y,
• sqrt(x) : racine carrée de x,
• ceil(x) : le plus petit entier supérieur ou égal à x,
• floor(x) : le plus grand entier inférieur ou égal à x,
• fabs(x) : |x|,

La compilation d'un programme faisant appel à ces fonctions doit être effectuée avec l'option -lm afin que l'éditeur de liens puissent résoudre les références externes correspondantes.

Sous UNIX SYSTEM V, la fonction matherr permet de gérer une erreur qui s'est produite lors de l'utilisation d'une fonction mathématique. Le programmeur peut écrire sa propre fonction matherr, laquelle doit respecter la syntaxe suivante :

     int matherr(struct exception *exp)
     

     struct exception
     {
         int    type;
         char  *name;
         double arg1, arg2, retval;
     };
     

• type : type de l'erreur,
  • DOMAIN : domaine erroné,
  • SING : valeur singulière,
  • OVERFLOW : dépassement de capacité,
  • UNDERFLOW : sous-dépassement de capacité,
  • PLOSS : perte partielle de chiffres significatifs,
  • TLOSS : perte totale de chiffres significatifs,
• name : nom de la fonction générant l'exception,
• arg1, arg2 : arguments avec lesquels la fonction a été invoquée,
• retval : valeur retournée par défaut, laquelle peut être modifiée par la fonction matherr.

Exemple

#include <stdio.h>
#include <math.h>
main()
{
  double x, y;

  scanf( "%lf", &x );
  y = log( x );
  printf( "%f\n", y );

  return 0;
}
int matherr( struct exception *p )
{
  puts( "erreur détectée" );
  printf( " type : %d\n", p->type );
  printf( " name : %s\n", p->name );
  printf( " arg1 : %f\n", p->arg1 );
  printf( " arg2 : %f\n", p->arg2 );
  printf( " valeur retournée : %f\n", p->retval );
  p->retval = -1.;

  return 0;
}
    

Retour début .

9.13 - Fonctions de recherche et de tri

Syntaxe

void *bsearch(const void *key, const void *base,
              size_t NbElt, size_t TailleElt,
              int (*cmp)(const void *, const void *))
    

Exemple

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main( int argc, char **argv )
{
  int cmp( const void *key, const void *elt );
  int tab[] = {10, 8, 7, 4, 2, 1, 0};
  int *ptr;
  int NbElt = sizeof tab / sizeof tab[0];
  int key = (int)strtol( argv[1], NULL, 0 );

  ptr = bsearch( &key, tab, NbElt,
                           sizeof(int), cmp );
  if( ptr )
    printf( "Rg de l'élt rech. : %d\n", ptr-tab+1 );
}
int cmp( const void *key, const void *elt )
{
  if( *(int *)key < *(int *)elt )
    return 1;
  else if( *(int *)key > *(int *)elt )
    return -1;
  else return 0;
}
    

La fonction qsort, dont la déclaration se trouve dans le fichier en-tête stdlib.h, permet de trier un vecteur. Cette fonction est une réalisation de l'algorithme de tri rapide («~quick-sort~») dû à Hoare (1962).

Syntaxe

void qsort(const void *base,
           size_t NbElt, size_t TailleElt,
           int (*cmp)(const void *, const void *))
    

Exemple

#include <stdio.h>
#include <stdlib.h>
main()
{
  int cmp( const void *elt1, const void *elt2 );
  double tab[] = {3., 10., 6., 101.,
                  7., 11., 6., 14.};
  int    NbElt = sizeof tab / sizeof tab[0];
  int    i;

  qsort( tab, NbElt, sizeof(double), cmp );
  printf( "Vecteur tab trié : \n" );
  for( i=0; i < NbElt; i++ )
    printf( "%f\n", tab[i] );
}
int cmp( const void *elt1, const void *elt2 )
{
  if( *(double *)elt1 < *(double *)elt2 )
    return 1;
  else if( *(double *)elt1 > *(double *)elt2 )
    return -1;
  else return 0;
}
    

Retour début

10 - Entrées-sorties de bas niveau

• 10.1 - Notion de descripteur de fichier
• 10.2 - Fonctions d'ouverture et de fermeture de fichier
• 10.3 - Fonctions de lecture et d'écriture
• 10.4 - Accès direct
• 10.5 - Relation entre flot et descripteur de fichier

Retour début .

10.1 - Notion de descripteur de fichier

Il existe une table des descripteurs de fichiers rattachée à chaque processus. La première entrée libre dans cette table est affectée lors de la création d'un descripteur de fichier.

Le nombre d'entrées de cette table, correspondant au nombre maximum de fichiers que peut ouvrir simultanément un processus, est donné par la pseudo-constante NOFILE définie dans le fichier en-tête «~sys/param.h~».

Retour début .

10.2 - Fonctions d'ouverture et de fermeture de fichier

Syntaxe

int  open(const char *fichier, int mode, mode_t acces)
int creat(const char *fichier, mode_t acces)
    

L'argument fichier indique le fichier à ouvrir.

L'argument mode indique le mode d'ouverture du fichier que l'on spécifie à l'aide de pseudo-constantes définies dans le fichier en-tête «~fcntl.h~» :

• O_RDONLY : lecture seulement,
• O_WRONLY : écriture seulement,
• O_RDWR : lecture et écriture,
• O_APPEND : écriture en fin de fichier,
• O_CREAT : si le fichier n'existe pas il sera créé,
• O_TRUNC : si le fichier existe déjà il est ramené à une taille nulle,
• O_EXCL : provoque une erreur si l'option de création a été indiquée et si le fichier existe déjà.

Ces pseudo-constantes peuvent être combinées à l'aide de l'opérateur booléen |.

L'appel creat est équivalent à open avec
O_WRONLY | O_CREAT | O_TRUNC comme mode d'accès.

L'appel à creat, ainsi qu'à open dans le cas où le mode O_CREAT a été indiqué, s'effectue avec un autre argument décrivant les accès UNIX du fichier à créer qui se combinent avec ceux définis au niveau de la commande umask du SHELL.

Ces fonctions retournent le descripteur de fichier ou -1 en cas d'erreur.

La fonction close permet de libérer le descripteur de fichier passé en argument.

Exemple

#include <stdio.h>
#include <fcntl.h>
main()
{
  int fd1, fd2;

  if( (fd1 = open( "Fichier1",
                    O_WRONLY|O_CREAT|O_TRUNC,
                    0644 )) == -1 )
  {
    perror( "open" );
    exit(1);
  }
  if( (fd2 = creat( "Fichier2", 0644 )) == -1 )
  {
    perror( "creat" );
    exit(2);
  }
       ...
  close( fd1 );
  close( fd2 );

  return 0;
}
     

Retour début .

10.3 - Fonctions de lecture et d'écriture

Syntaxe

int  read(int fd, char *buffer, int NbOctets)
int write(int fd, char *buffer, int NbOctets)
    

Une valeur de retour de read égale à 0 signifie fin de fichier.

Une valeur de retour égale à -1 correspond à la détection d'une erreur d'entrée-sortie.

Exemple

#include <stdio.h>
#include <fcntl.h>
main()
{
  int  fde, fds;
  char buffer[BUFSIZ];
  int  nlus;

  if( (fde = open( "entree", O_RDONLY )) == -1 )
  {
    perror( "open" );
    exit(1);
  }
  if( (fds = creat( "sortie", 0644 )) == -1 )
  {
    perror( "creat" );
    exit(2);
  }
  while( nlus = read( fde, buffer, sizeof(buffer) ) )
    write( fds, buffer, nlus );
  close( fde );
  close( fds );

  return 0;
}
     

Retour début .

10.4 - Accès direct

Les fonctions tell et lseek permettent de récupérer et de positionner le pointeur de position courante. Elles sont déclarées dans le fichier en-tête unistd.h.

Syntaxe

off_t lseek(int fd, off_t decalage, int origine)
int   tell(int fd)
    

Exemple

#include <unistd.h>

/*
 *  fonction lisant n octets à partir
 *  de la position courante.
 */

int lire( int fd, long pos, char *buffer, int n )
{
   if( lseek( fd, pos, 0 ) > = 0 )
     return read( fd, buffer, n );
   else return -1;
}
    

Retour début .

10.5 - Relation entre flot et descripteur de fichier

Il est possible de changer de mode de traitement d'un fichier c'est-à-dire passer du mode flot («~stream~») au mode descripteur («~bas niveau~») ou vice-versa.

Pour ce faire, il existe :

• la pseudo-fonction fileno qui permet de récupérer le descripteur à partir d'une structure de type FILE,
• la fonction fdopen qui permet de créer une structure de type FILE et de l'associer à un descripteur.

Syntaxe

int   fileno(FILE *f)
FILE *fdopen(const int fd, const char *type)
    

Ces deux fonctions sont déclarées dans le fichier en-tête stdio.h.

Exemple

#include <stdio.h>
main()
{ int   fd;
  FILE *fe, *fs;
  char  buffer[BUFSIZ];

  if( (fd = creat( "copie", 0644 )) == -1 )
    perror( "creat" ), exit(1);
  write( fd, "abcdefg", 7 );
  if( (fe = fopen( "entree", "r" )) == NULL )
    perror( "fopen" ), exit(2);
  printf( "Descripteur du fichier \"entree\" : "
          "%d\n", fileno(fe) );
  if( (fs = fdopen( fd, "w" )) == NULL )
    perror( "fdopen" ), exit(3);
  fgets( buffer, sizeof buffer, fe );
  while( ! feof(fe) )
  {
    fputs( buffer, fs );
    fgets( buffer, sizeof buffer, fe );
  }
  fclose( fe ); fclose( fs );

  return 0;
}
    

Retour début

11 - Annexe A

Table des codes ASCII des caractères

Caractère	déc.	hexa.	octal	Caractère	déc.	hexa.	octal
@	64	0x40	100	`	96	0x60	140
A	65	0x41	101	a	97	0x61	141
B	66	0x42	102	b	98	0x62	142
C	67	0x43	103	c	99	0x63	143
D	68	0x44	104	d	100	0x64	144
E	69	0x45	105	e	101	0x65	145
F	70	0x46	106	f	102	0x66	146
G	71	0x47	107	g	103	0x67	147
H	72	0x48	110	h	104	0x68	150
I	73	0x49	111	i	105	0x69	151
J	74	0x4a	112	j	106	0x6a	152
K	75	0x4b	113	k	107	0x6b	153
L	76	0x4c	114	l	108	0x6c	154
M	77	0x4d	115	m	109	0x6d	155
N	78	0x4e	116	n	110	0x6e	156
O	79	0x4f	117	o	111	0x6f	157
P	80	0x50	120	p	112	0x70	160
Q	81	0x51	121	q	113	0x71	161
R	82	0x52	122	r	114	0x72	162
S	83	0x53	123	s	115	0x73	163
T	84	0x54	124	t	116	0x74	164
U	85	0x55	125	u	117	0x75	165
V	86	0x56	126	v	118	0x76	166
W	87	0x57	127	w	119	0x77	167
X	88	0x58	130	x	120	0x78	170
Y	89	0x59	131	y	121	0x79	171
Z	90	0x5a	132	z	122	0x7a	172
[	91	0x5b	133	{	123	0x7b	173
\	92	0x5c	134	|	124	0x7c	174
]	93	0x5d	135	}	125	0x7d	175
^	94	0x5e	136	~	126	0x7e	176
_	95	0x5f	137	C-?	127	0x7f	177

Retour début

12 - Annexe B

Priorité des opérateurs

Retour début

13 - Annexe C

• Exercices : énoncés/corrigés
  • Exercice 1 : (Énoncé / Corrigé)
  • Exercice 2 : (Énoncé / Corrigé)
  • Exercice 3 : (Énoncé / Corrigé)
  • Exercice 4 : (Énoncé / Corrigé)
  • Exercice 5 : (Énoncé / Corrigé)
  • Exercice 6 : (Énoncé / Corrigé)
  • Exercice 7 : (Énoncé / Corrigé)
  • Exercice 8 : (Énoncé / Corrigé)
  • Exercice 9 : (Énoncé / Corrigé)
  • Exercice 10 : (Énoncé / Corrigé)
  • Exercice 11 : (Énoncé / Corrigé)
  • Exercice 12 : (Énoncé / Corrigé)
  • Exercice 13 : (Énoncé / Corrigé)
  • Exercice 14 : (Énoncé / Corrigé)
  • Exercice 15 : (Énoncé / Corrigé)

  • Accéder aux fichiers des exercices

Retour début

Énoncés des exercices

.

Exercice 1

Soit un programme contenant les déclarations suivantes :

    int   i =  8;
    int   j =  5;
    float x =  0.005f;
    float y = -0.01f;
    char  c = 'c';
    char  d = 'd';
    

Déterminer la valeur de chacune des expressions suivantes :

1. (3*i - 2*j)\%(2*d - c)
2. 2*((i/5) + (4*(j-3))\%(i + j - 2))
3. i <= j
4. j != 6
5. c == 99
6. 5*(i + j) > 'c'
7. (i > 0) && (j < 5)
8. (i > 0) || (j < 5)
9. (x > y) && (i > 0) || (j < 5)
10. (x > y) && (i > 0) && (j < 5)

Corrigé ou retour début chapitre .

Exercice 2

Soit un programme contenant les déclarations suivantes :

  char *argv[] = {
            "Wolfgang Amadeus Mozart",
            "Ludwig van Beethoven",
            "Hector Berlioz",
            "Nicolo Paganini" };
  char **p = argv;
  

1	(*p++)[1]	1	(*p++)[1]
2	*p++[1]	2	*p[1]++
3	(*++p)[4]	3	(*++p)[4]
4	*++*p	4	*++*p

Corrigé ou retour début chapitre .

Exercice 3

Analyser les expressions contenues dans le programme suivant :

#include <stdio.h>
main()
{
  int a;
  int b;
  int c;

  a = 16;
  b = 2;
  c = 10;

  c += a > 0 && a <= 15 ? ++a : a/b;
  /*
   * Que dire de l'expression suivante ? :
   * -----------------------------------
   */
  a > 30 ? b = 11 : c = 100;
}
    

Corrigé ou retour début chapitre .

Exercice 4

Calculer parmi les entiers de 1 à 100 :

1. la somme des entiers pairs,
2. la somme des carrés des entiers impairs,
3. la somme des cubes de ces entiers.

Corrigé ou retour début chapitre .

Exercice 5

Écrire un programme permettant d'effectuer le produit de 2 matrices A et B. Leurs profils seront définis à l'aide de constantes symboliques. La matrice résultat C sera imprimée ligne par ligne.

Corrigé ou retour début chapitre .

Exercice 6

Écrire un programme permettant de déterminer les nombres premiers dans l'intervalle [1,n] à l'aide du crible d'Ératosthène. Il consiste à former une table avec tous les entiers naturels compris entre 2 et n et à rayer (mise à zéro), les uns après les autres, les entiers qui ne sont pas premiers de la manière suivante : dès que l'on trouve un entier qui n'a pas encore été rayé, il est déclaré premier, et on raye tous les multiples de celui-ci. À la fin du procédé, les nombres non barrés sont des nombres premiers. On tiendra compte du fait qu'un nombre donné peut déjà avoir été éliminé en tant que multiple de nombres précédents déjà testés. Par ailleurs, on sait que l'on peut réduire la recherche aux nombres de 2 à sqrt(n) (si un entier non premier est strictement supérieur à sqrt(n) alors il a au moins un diviseur inférieur à sqrt(n) et aura donc déjà été rayé).

Corrigé ou retour début chapitre .

Exercice 7

Remplir un tableau de 12 lignes et 12 colonnes à l'aide des caractères '1', '2' et '3' tel que :

         1
         1 2
         1 2 3
         1 2 3 1
         1 2 3 1 2
         1 2 3 1 2 3
         1 2 3 1 2 3 1
         1 2 3 1 2 3 1 2
         1 2 3 1 2 3 1 2 3
         1 2 3 1 2 3 1 2 3 1
         1 2 3 1 2 3 1 2 3 1 2
         1 2 3 1 2 3 1 2 3 1 2 3
    

Corrigé ou retour début chapitre .

Exercice 8

Écrire un programme permettant de trier les vecteurs lignes d'une matrice de nombres en ordre croissant. On s'appuiera sur l'algorithme appelé «~tri à bulle~» qui consiste à comparer 2 éléments consécutifs et les intervertir si nécessaire. Si après avoir terminé l'exploration du vecteur au moins une interversion a été effectuée, on renouvelle l'exploration, sinon le tri est terminé. Chaque ligne à trier sera transmise à une fonction qui effectuera le tri.

Corrigé ou retour début chapitre .

Exercice 9

Le but de cet exercice est de transformer une matrice de réels que l'on se définira. Cette transformation consiste à modifier chaque élément à l'aide d'une fonction paramétrable de la forme y = f(x). On définira plusieurs fonctions de ce type. La valeur d'un entier défini sous la forme d'une constante symbolique indiquera la fonction à transmettre en argument de la procédure chargée d'effectuer la transformation.

Corrigé ou retour début chapitre .

Exercice 10

Écrire une fonction à laquelle on transmet des couples (entier, réel) en nombre variable, et qui retourne les sommes des entiers et des réels.

Corrigé ou retour début chapitre .

Exercice 11

Écrire un programme qui analyse les paramètres qui lui sont passés. Ce programme devra être appelé de la manière suivante :

exo11 -a chaine1|-b chaine2|-c chaine3 [-d -e -f] fichier

1. une seule des options -a, -b ou -c doit être spécifiée, suivie d'une chaîne,
2. les options -d, -e, -f sont facultatives. Si aucune d'entre elles n'est indiquée, le programme doit les considérer comme toutes présentes,
3. un nom de fichier doit être spécifié.

1. exo11 -a chaîne -e fichier
2. exo11 -b chaîne fichier -d -f
3. exo11 -c chaîne fichier -df
   (regroupement des options -d et -f).

Corrigé ou retour début chapitre .

Exercice 12

Écrire un programme qui lit des mots sur l'entrée standard et les affiche après les avoir converti en louchebem («~langage des bouchers~»).

Cette conversion consiste à :

1. reporter la 1^ère lettre du mot en fin de mot, suivie des lettres 'e' et 'm',
2. remplacer la 1^ère lettre du mot par la lettre 'l'.

1. vison ==> lisonvem,
2. vache ==> lachevem,
3. bonne ==> lonnebem.

Corrigé ou retour début chapitre .

Exercice 13

Écrire une fonction myatof qui convertit la chaîne passée en argument, en un réel de type «~double~».

On pourra comparer le résultat obtenu avec celui de la fonction «~atof~» de la bibliothèque standard.

Corrigé ou retour début chapitre .

Exercice 14

Écrire un programme qui lit des chaînes de caractères sur l'entrée standard.

À la rencontre de la chaîne «~la~», il affichera la liste des chaînes déjà saisies.

À la rencontre de la chaîne «~li~», il affichera cette liste dans l'ordre inverse.

Corrigé ou retour début chapitre .

Exercice 15

Écrire un programme dont le but est de créer, à partir du fichier «~musiciens~», deux fichiers :

1. un fichier constitué des enregistrements du fichier «~musiciens~», mis les uns à la suite des autres en supprimant le caractère «~newline~» qui les sépare,
2. un fichier d'index dans lequel seront rangées les positions ainsi que les longueurs des enregistrements du fichier précédent.

Corrigé ou retour début chapitre .

Exercice 16

Ce programme devra, à partir des fichiers créés par le programme de l'exercice 15, afficher :

1. la liste des enregistrements du fichier indexé des musiciens,
2. cette même liste triée par ordre alphabétique des noms des musiciens,
3. cette même liste triée par ordre chronologique des musiciens,
4. le nom du musicien mort le plus jeune, ainsi que sa durée de vie.

Corrigé ou retour début chapitre .

Exercice 17

Écrire un programme qui affichera l'enregistrement du fichier indexé des musiciens, créé par le programme de l'exercice 15, dont le rang est passé en argument. (Prévoir les cas d'erreurs).

Corrigé ou retour début chapitre .

Exercice 18

Écrire une fonction qui retourne les différentes positions d'une chaîne de caractères dans un fichier texte ou binaire.

Le nom du fichier, ainsi que la chaîne seront transmis en argument au programme.

On pourra le tester avec les arguments suivants :

1. exo18 exo18_data_bin save
2. exo18 exo18_data_bin SAVE
3. exo18 exo18_data_txt où-suis-je?

Corrigé ou retour début chapitre .

Exercice 19

Écriture d'un programme intéractif de gestion d'une liste chaînée.

Ce programme affichera le menu suivant :

1 - AJOUTS d'éléments dans une liste chaînée.
2 - AFFICHAGE de la liste chaînée.
3 - TRI de la liste chaînée.
4 - SUPPRESSION d'éléments dans la liste.
5 - VIDER la liste.
6 - ARRÊT du programme.
    

Retour début chapitre .

Corrigés des exercices

Corrigé de l'exercice 1

   int   i =  8;
   int   j =  5;
   float x =  0.005f;
   float y = -0.01f;
   char  c = 'c';
   char  d = 'd';
    

Retour début chapitre .

Corrigé de l'exercice 2

  char *argv[] = {
            "Wolfgang Amadeus Mozart",
            "Ludwig van Beethoven",
            "Hector Berlioz",
            "Nicolo Paganini" };
  char **p = argv;
  

Retour début chapitre .

Corrigé de l'exercice 3

#include <stdio.h>
§MEVBCBfint main()
{
  int a;
  int b;
  int c;

  a = 16;
  b = 2;
  c = 10;

  /*
   * 1) on commence par évaluer l'expression
   *    a > 0 && a <= 15, laquelle constitue
   *    le 1er opérande de l'opérateur ?:.
   *    Celle-ci est fausse car les expressions
   *    a > 0 et a <= 15 sont vraie et
   *    fausse respectivement,
   * 2) on évalue donc le 3eme opérande de l'opérateur
   *    ?:, c'est-à-dire l'expression a/b,
   * 3) et enfin on effectue l'affectation.
   */
  c += a > 0 && a <= 15 ? ++a : a/b;
  printf( "c : %d\n", c );  ===>  18
  

  /*
   * Que dire de l'expression suivante? :
   * ----------------------------------
   */
  a > 30 ? b = 11 : c = 100;

  /*
   * Cette expression provoque une erreur
   * à la compilation car le troisième
   * opérande de l'opérateur ?: est c
   * et non pas c = 100. De ce fait,
   * l'expression a > 30 ? b = 11 : c
   * est d'abord évaluée. Sa valeur est ensuite utilisée
   * comme opérande de gauche de la dernière affectation.
   * D'où l'erreur, car cette valeur n'est pas une g-valeur.
   *
   * On devrait écrire :
   */

  a > 30 ? b = 11 : (c = 100);

  return 0;
}
  

Retour début chapitre .

Corrigé de l'exercice 4

#include <stdio.h>

§MEVBCBfint main()
{
  int pairs, carres_impairs, cubes;
  int i;

  pairs = carres_impairs = cubes = 0;
  /* Boucle de calcul.*/
  for (i=1; i<=100; i++)
  {
    cubes += i*i*i;
    /* "i" est-il pair ou impair?*/
    i%2 ? carres_impairs += i*i : (pairs += i);
  }
  /*
   * Impression des résultats.
   */
  printf( "Somme des entiers pairs entre 1 et 100 : "
          "%d\n", pairs );
  printf( "Somme des carrés des entiers impairs entre"
          " 1 et 100 : %d\n", carres_impairs );
  printf( "Somme des cubes des 100 premiers "
          "entiers : %d\n", cubes );

  printf( "\n\nFin EXO4.\n" );

  return 0;
}
  

Retour début chapitre .

Corrigé de l'exercice 5

#include <stdio.h>

§MEVBCBfint main()
{
  const int n = 10;
  const int m = 5;
  const int p = 3;
  double    a[][5] =
      {
        { 0.00, 0.38, 0.42, 0.91, 0.25 },
        { 0.13, 0.52, 0.69, 0.76, 0.98 },
        { 0.76, 0.83, 0.59, 0.26, 0.72 },
        { 0.46, 0.03, 0.93, 0.05, 0.75 },
        { 0.53, 0.05, 0.85, 0.74, 0.65 },
        { 0.22, 0.53, 0.53, 0.33, 0.07 },
        { 0.05, 0.67, 0.09, 0.63, 0.63 },
        { 0.68, 0.01, 0.65, 0.76, 0.88 },
        { 0.68, 0.38, 0.42, 0.99, 0.27 },
        { 0.93, 0.07, 0.70 ,0.37, 0.44 }
      };
  double    b[][3] =
      {
        { 0.76, 0.16, 0.9047 },
        { 0.47, 0.48, 0.5045 },
        { 0.23, 0.89, 0.5163 },
        { 0.27, 0.90, 0.3190 },
        { 0.35, 0.06, 0.9866 }
      };
  double    c[10][3];
  int       i,j,k;
  

                 /* Produit matriciel C = A*B */
  for( i=0; i

#include <stdio.h>
#include <math.h>

§MEVBCBfint main()
{
  const int n = 1000;
  int       tab_nombres[n];
  int       imax;
  int       i, j;

  /*
   * Remplissage du tableau "tab_nombres"
   * à l'aide des nombres de 1 à 1000.
   */
  for( i=1; i

  /*
   * Impression des nombres non exclus
   * qui sont les nombres premiers cherchés.
   * Impression de 10 nombres par ligne.
   */
  printf( "Les nombres premiers entre 1 et "
          "%d sont :\n\n", n );
  for( i=1; i

#include <stdio.h>

§MEVBCBfint main()
{
  int  i, j;
  char c, tab[12][12];

  /* Boucle sur les colonnes.*/
  for( j=0; j<12; )
    /*
     * On remplit par groupe de 3 colonnes avec
     * les caractères successifs '1', '2'  et '3'.
     */
    for( c='1'; c<='3'; c++, j++ )
      for( i=j; i<12; i++ )
        tab[i][j] = c;
  /*
   * Impression du tableau obtenu.
   */
  for( i=0; i<12; i++ )
  {
    for( j=0; j<=i; j++ )
      printf( "  %c", tab[i][j] );
    printf( "\n" );
  }

  printf( "\n\nFin EXO7.\n" );

  return 0;
}
  

#include <stdio.h>

#define NbElts(t) ( (sizeof(t)) / (sizeof(t[0])) )
#define NCOLS 4
typedef enum { False, True } Boolean;

§MEVBCBfint main()
{
  void   tri_vec( double *t );
  double mat[][NCOLS] =
         {
           {  1.56,    0.89,  10.234,  2.78  },
           {  9.789,   2.67,  39.78,  22.34  },
           { 99.99,  324.678,  4.56,   8.567 }
         };
  int i, j;

  /* Tri de chaque vecteur ligne.*/
  for( i=0; i

/*
 * Fonction effectuant le tri d'un vecteur
 * par la méthode du tri à "bulles".
 */
§MEVBCBfvoid tri_vec( double *t )
{
  Boolean tri_termine;
  int     i;

  for( ;; )
  {
    tri_termine = True;
    for( i=0; i t[i+1] )
      {
        double temp;

        temp = t[i+1];
        t[i+1] = t[i];
        t[i] = temp;
        tri_termine = False;
      }
    if ( tri_termine ) break;
  }

  return;
}
  

#include <stdio.h>
#include <math.h>

#define NbElts(t) ( (sizeof(t)) / (sizeof(t[0])) )
#define NCOLS 4

/* Fonctions de transformations.*/
double identite( double x ) { return x; }

double carre   ( double x ) { return x*x; }

double cubes   ( double x ) { return x*x*x; }

§MEVBCBfint main()
{
  void transform( double (*)[NCOLS],
                  int    nb_lignes,
                  double (*f)( double ) );
  const int choix = 4;

  double mat[][NCOLS] =
         {
           {  1.56,    0.89,  10.234,  2.78 },
           {  9.789,   2.67,  39.78,  22.34 },
           { 99.99,  324.678,  4.56,   8.567 }
         };
  int i, j;
  

  switch( choix )
  {
    case 1:
      transform( mat, NbElts(mat), identite );
      break;
    case 2:
      transform( mat, NbElts(mat), carre );
      break;
    case 3:
      transform( mat, NbElts(mat), cubes );
      break;
    case 4:
      transform( mat, NbElts(mat), log );
      break;
  }

  /* Impression de la matrice transformée.*/
  for( i=0; i

/* Fonction effectuant la transformation.*/
§MEVBCBfvoid transform( double (*p)[NCOLS],
                §MEVBCBfint    nb_lignes,
                §MEVBCBfdouble (*f)( double ) )
{
  int i, j;

  for( i=0; i

#include <stdio.h>
#include <stdarg.h>

typedef struct somme
{
  int    entiers;
  double reels;
} Somme;

§MEVBCBfint main()
{
  Somme sigma( int nb_couples, ... );
  Somme s;

  s = sigma( 4, 2, 3., 3, 10., 3, 5., 11, 132. );
  printf( " Somme des entiers : %d\n", s.entiers );
  printf( " Somme des réels   : %f\n", s.reels );
  printf( "\t\t------------------\n" );
  s = sigma( 5, 2, 3., 3, 10., 3, 5., 11, 132., 121, 165. );
  printf( " Somme des entiers : %d\n", s.entiers );
  printf( " Somme des réels   : %f\n", s.reels );

  printf( "\n\nFin EXO10.\n" );

  return 0;
}
  

§MEVBCBfSomme sigma( int nb_couples, ... )
{
  Somme   s;
  int     i;
  va_list arg;

  /*
   * Initialisation de "arg" avec l'adresse
   * de l'argument qui suit "nb_couples".
   * ("arg" pointe sur l'entier du 1er couple).
   */
  va_start( arg, nb_couples );
  s.entiers = s.reels = 0;
  /*
   * Boucle de récupération des valeurs.
   */
  for( i=0; i

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

void traitement_option( const unsigned char option );
void usage( char *s );

const unsigned char  option_a = 1;
const unsigned char  option_b = 2;
const unsigned char  option_c = 4;
const unsigned char  option_d = 8;
const unsigned char  option_e = 16;
const unsigned char  option_f = 32;
unsigned char        mask_options = 0;
char                *valeur_option = NULL, *fichier = NULL;
char                *module;

void bilan_options( void );
  

§MEVBCBfint main( int argc, char **argv )
{
  /* Sauvegarde du nom de l'exécutable. */
  module = strdup( *argv );
  /* Boucle sur les arguments. */
  while( *++argv != NULL )
  {
    /*
     * Est-ce que l'argument commence
     * par le caractère '-' ?
     */

    if( (*argv)[0] == '-' )
    {
      /* On analyse les caractères qui suivent. */
      for( (*argv)++; **argv; (*argv)++ )
      {
        switch( **argv )
        {
          case 'a':
            traitement_option( option_a );
            break;
          case 'b':
            traitement_option( option_b );
            break;
          case 'c':
            traitement_option( option_c );
            break;
          case 'd':
            traitement_option( option_d );
            break;
  

          case 'e':
            traitement_option( option_e );
            break;
          case 'f':
            traitement_option( option_f );
            break;
          default : usage( module );
        }
        if ( **argv == 'a' || **argv == 'b' || **argv == 'c' )
        {
          /*
           * La valeur de l'option 'a', 'b' ou 'c' peut
           * suivre immédiatement, ou bien être séparée
           * de l'option par des blancs.
           */
          if( *++*argv != '\0' )
            valeur_option = strdup( *argv );
          /* Cas où aucune valeur ne suit. */
          else if( (*++argv)[0] == '-' )
            usage( module );
          else
            valeur_option = strdup( *argv );
          break;
        }
      }
    }
  

    /*
     * L'argument ne commence pas
     * par le caractère '-'.
     */
    else if( fichier != NULL )
      usage( module );
    else
      fichier = strdup( *argv );
  }
  bilan_options();

  printf( "\n\nFin EXO11.\n" );

  return 0;
}

§MEVBCBfvoid bilan_options( void )
{
  /*
   * L'option 'a', 'b', ou 'c' suivie d'une
   * chaîne, ainsi qu'un nom de fichier
   * doivent être spécifiés.
   */

  if( valeur_option == NULL || fichier == NULL )
    usage( module );
  

  /*
   * Si aucune des options 'd', 'e', 'f'
   * n'a été spécifiée, on les considère toutes.
   */

  if( ! (mask_options & option_d) &&
      ! (mask_options & option_e) &&
      ! (mask_options & option_f) )
    mask_options |= option_d + option_e + option_f;
  if( mask_options & option_a )
    printf( "Option \"a\" fournie avec comme valeur : "
            "%s\n", valeur_option );
  if( mask_options & option_b )
    printf( "Option \"b\" fournie avec comme valeur : "
            "%s\n", valeur_option );
  if( mask_options & option_c )
    printf( "Option \"c\" fournie avec comme valeur : "
            "%s\n", valeur_option );
  printf( "Option \"d\" %s.\n",
           mask_options & option_d ? "active" : "inactive" );
  printf( "Option \"e\" %s.\n",
           mask_options & option_e ? "active" : "inactive" );
  printf( "Option \"f\" %s.\n",
           mask_options & option_f ? "active" : "inactive" );

  printf( "fichier indiqué : %s\n", fichier );

  return;
}
  

§MEVBCBfvoid traitement_option( const unsigned char option )
{
  /*
   * Une seule des options "-a", "-b", "-c"
   * doit avoir été spécifiée.
   */

  if ( option == option_a ||
       option == option_b ||
       option == option_c )
    if ( valeur_option != NULL )
      usage( module );

  /*
   * On interdit qu'une option
   * soit indiquée 2 fois.
   */

  if ( mask_options & option )
    usage( module );
  else
    mask_options |= option;

  return;
}

§MEVBCBfvoid usage( char *s )
{
  printf( "usage : %s -a chaine | -b chaine"
          " | -c chaine [-d -e -f] fichier\n", s );
  exit(1);
}
  

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

typedef enum { False, True } Boolean;
typedef struct options
{
  char     nom[3];
  Boolean  option_fournie;
  Boolean  option_a_valeur;
  char    *valeur;
} Option;
typedef enum { option_a, option_b, option_c,
               option_d, option_e, option_f,
               nb_options, option_invalide } option_t;

Option options[] = {
                     { "-a", False, True,  NULL },
                     { "-b", False, True,  NULL },
                     { "-c", False, True,  NULL },
                     { "-d", False, False, NULL },
                     { "-e", False, False, NULL },
                     { "-f", False, False, NULL }
                   };

option_t type_option( char *option );
void     bilan_options( void );
void     usage(char *s);

char *module, *fichier = NULL;
  

§MEVBCBfint main( int argc, char **argv )
{
  /* Sauvegarde du nom de l'exécutable. */
  module = strdup( *argv );

  /* Boucle sur les arguments. */
  while( *++argv != NULL )
  {
    /*
     * Est-ce que l'argument commence
     * par le caractère '-' ?
     */

    if( (*argv)[0] == '-' )
    {
      option_t opt;

      opt = type_option( *argv );
      if( opt == option_invalide ) usage( module );
      if( options[opt].option_a_valeur )
      {
        *argv += strlen( options[opt].nom );
        if( argv[0][0] != '\0' )
          options[opt].valeur = strdup( *argv );
        /* Cas où aucune valeur ne suit. */
        else if( (++argv)[0][0] == '-' )
          usage( module );
        else
          options[opt].valeur = strdup( *argv );
      }
    }
  

    else if( fichier != NULL )
      usage( module );
    else
      fichier = strdup( *argv );
  }

  bilan_options();

  printf("\n\nFin EXO11.\n");

  return 0;
}

§MEVBCBfoption_t type_option( char *option )
{
  option_t rang;

  for( rang=0; rang

§MEVBCBfvoid bilan_options( void )
{
  option_t rang;

  /*
   * Une seule des options "-a", "-b", "-c"
   * doit avoir été spécifiée ainsi qu'un
   * nom de fichier.
   */

  if( options[option_a].option_fournie ^
      options[option_b].option_fournie ^
      options[option_c].option_fournie &&
      fichier != NULL )
  {
    if ( options[option_a].option_fournie &&
         options[option_b].option_fournie &&
         options[option_c].option_fournie ) usage( module );

    /*
     * Si aucune des options 'd', 'e', 'f'
     * n'a été spécifiée, on les considère toutes.
     */

    if( ! options[option_d].option_fournie &&
        ! options[option_e].option_fournie &&
        ! options[option_f].option_fournie )
      options[option_d].option_fournie =
      options[option_e].option_fournie =
      options[option_f].option_fournie = True;
  

    for( rang=0; rang

#include <stdio.h>

§MEVBCBfint main()
{
  char  buffer[BUFSIZ];
  char *p;

  /*
   * Boucle de lecture sur l'entrée standard
   * avec la chaîne "--> " comme prompt.
   */
  fputs( "--> ", stdout );
  gets( buffer );
  while( ! feof(stdin) )
  {
    /* On se positionne à la fin du mot lu. */
    for( p=buffer; *p; p++ );
    /* Conversion du mot en "louchebem". */
    p[0] = *buffer;
    *buffer = 'l';
    p[1] = 'e'; p[2] = 'm'; p[3] = '\0';
    puts( buffer );
    fputs( "--> ", stdout );
    gets( buffer );
  }

  printf( "\n\nFin EXO12.\n" );

  return 0;
}
  

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

§MEVBCBfint main( int argc, char **argv )
{
  void   usage ( char *s );
  double myatof( char *s );

  /* Y a-t-il un argument ? */
  if( argc != 2 ) usage( argv[0] );
  /*
   * On imprime les résultats des fonctions
   * "atof" et "myatof" pour comparaison.
   */
  printf( "%f\n", atof  ( argv[1] ) );
  printf( "%f\n", myatof( argv[1] ) );

  printf("\n\nFin EXO13.\n");

  return 0;
}

§MEVBCBfdouble myatof( char *s )
{
  long   nombre, signe;
  double exposant;

  exposant = 1.;
  nombre   = 0;
  

  /*
   * Saut des éventuels caractères
   * espace, tabulation et "newline"
   * situés en tête.
   */
  for( ; isspace( *s ); s++ )
      ;
  /* Gestion du signe. */
  signe = *s == '-' ? -1 : 1;
  *s == '-' || *s == '+' ? s++ : s;
  /* Gestion de la partie entière. */
  for( ; isdigit( *s ); s++ )
    nombre = nombre*10 + *s - '0';
  if( *s++ != '.' )
    return signe*nombre*exposant;
  /* Gestion de la partie décimale. */
  for( ; isdigit( *s ); s++ )
  {
    nombre = nombre*10 + *s - '0';
    exposant /= 10.;
  }

  return signe*nombre*exposant;
}

§MEVBCBfvoid usage( char *s )
{
  fprintf( stderr, "usage: %s nombre.\n", s );
  exit( 1 );
}
  

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

/* Définitions de nouveaux types. */
typedef enum sens {arriere, avant} Sens;
typedef struct cellule
{
   char   *chaine;
   struct  cellule *ptr_precedent;
   struct  cellule *ptr_suivant;
} CEL;

void  liste ( CEL *p, Sens sens );
void  libere( CEL *p );
CEL  *debut = NULL;

§MEVBCBfint main()
{
  CEL  *ptr_courant = NULL;
  char  chaine[40];

  /*
   * Boucle de lecture sur l'entrée standard
   * avec "--> " comme prompt.
   */
  fputs( "--> ", stdout );
  gets( chaine );
  

  while( ! feof( stdin ) )
  {
    /*
     * Si "la" est la chaîne entrée,
     * on liste les chaînes déjà saisies.
     */
    if( ! strcmp( chaine, "la" ) )
      liste( debut, avant );
    /*
     * Si "li" est la chaîne entrée,
     * on liste les chaînes déjà saisies
     * dans l'ordre inverse.
     */
    else if( ! strcmp( chaine, "li" ) )
      liste( ptr_courant, arriere );
    else
    {
      /* C'est la 1ère chaîne. */
      if( debut == NULL )
      {
        debut = malloc( sizeof(CEL) );
        debut->ptr_precedent = NULL;
        ptr_courant = debut;
      }
      else
      {
        /* C'est une chaîne différente de la 1ère. */
        ptr_courant->ptr_suivant = malloc( sizeof(CEL) );
        ptr_courant->ptr_suivant->ptr_precedent = ptr_courant;
        ptr_courant = ptr_courant->ptr_suivant;
      }
  

      /* On valorise le nouvel élément de la liste. */
      ptr_courant->chaine = strdup( chaine );
      ptr_courant->ptr_suivant = NULL;
    }
    fputs( "--> ", stdout );
    gets( chaine );
  }
  /* On libère la liste. */
  if( debut != NULL )
    libere( debut );

  printf( "\n\nFin EXO14.\n" );

  return 0;
}

/* Fonction récursive d'affichage de la liste. */
§MEVBCBfvoid liste( CEL *p, Sens sens )
{
  if( debut == NULL )
  {
    printf( "Désolé! la liste est vide.\n\n" );
    return;
  }
  if ( p != NULL )
  {
    printf( "\t%s\n", p->chaine );
    liste( sens == avant ?
              p->ptr_suivant : p->ptr_precedent, sens );
  }

  return;
}
  

/*
 * Fonction libérant la mémoire
 * occupée par la liste.
 */

§MEVBCBfvoid libere( CEL *p )
{
  if ( p->ptr_suivant != NULL )
    libere( p->ptr_suivant );

  free( p->chaine );
  free( p );

  return;
}
  

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

§MEVBCBfint main()
{
  typedef struct index
  {
     unsigned int debut;
     unsigned int longueur;
  } INDEX;
  FILE  *mus, *ind, *indmus;
  char   buffer[BUFSIZ];
  INDEX  index;

  /* Ouverture du fichier texte "musiciens". */
  if( (mus = fopen( "musiciens", "r" )) == NULL )
  {
    perror( "fopen" );
    exit(1);
  }
  /*
   * Ouverture en écriture du fichier
   * indexé des musiciens,
   */
  if( (ind = fopen( "index", "w" )) == NULL )
  {
    perror( "fopen" );
    exit(2);
  }
  

  /* Ouverture en écriture du fichier d'index. */
  if( (indmus = fopen( "indmus", "w" )) == NULL )
  {
    perror( "fopen" );
    exit(3);
  }

  index.debut = ftell( mus );
  /* Boucle de lecture du fichier des musiciens. */
  fgets( buffer, sizeof buffer, mus );
  while( ! feof(mus) )
  {
    static int n = 0; /* nombre de caractères "newline". */

    /* On supprime le caractère "newline". */
    buffer[strlen( buffer )-1] = '\0'; n++;
    fputs( buffer, indmus );
    index.longueur = strlen( buffer );
    fwrite( &index, sizeof index, 1, ind );
    /*
     * Mise à jour de la position pour
     * l'itération suivante.
     */
    index.debut = ftell( mus ) - n;
    fgets( buffer, sizeof buffer, mus );
  }
  /* Fermeture des fichiers. */
  fclose( ind ); fclose( indmus ); fclose( mus );

  printf( "\n\nFin EXO15.\n" );

  return 0;
}
  

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

/* Définition de types. */
typedef struct date
{
  unsigned int date_naiss;
  unsigned int date_mort;
} DATE;
typedef struct musicien
{
  char nom[30];
  char prenom[20];
  DATE date;
} MUSICIEN;
typedef struct index
{
  unsigned int debut;
  unsigned int longueur;
} INDEX;
  

§MEVBCBfint main()
{
  MUSICIEN  mort_le_plus_jeune( MUSICIEN *mus, int n );
  void      imprime           ( MUSICIEN *mus, int n );
  int       cmp_alpha ( const void *mus1, const void *mus2 );
  int       cmp_chrono( const void *mus1, const void *mus2 );
  FILE     *index, *mus;
  INDEX     ind;
  MUSICIEN *p_mus;
  MUSICIEN  mus_mort_le_plus_jeune;
  char     *buffer;
  int       NbMus;

  /* Ouverture du fichier index. */
  if( (index = fopen( "index", "r" )) == NULL )
  {
    perror( "fopen" );
    exit(1);
  }
  /* Ouverture du fichier indexé des musiciens. */
  if( (mus = fopen( "indmus", "r" )) == NULL )
  {
    perror( "fopen" );
    exit(2);
  }
  NbMus = 0;
  p_mus = NULL;
  /*
   * Boucle de lecture du fichier indexé des musiciens,
   * par l'intermédiaire du fichier d'index.
   */
  

  fread( &ind, sizeof(INDEX), 1, index );
  while( ! feof(index) )
  {
    buffer = malloc( ind.longueur+1 );
    fgets( buffer, ind.longueur+1, mus );
    p_mus = realloc( p_mus, ++NbMus*sizeof(MUSICIEN) );
    sscanf( buffer, "%s%s%d%d",
                      p_mus[NbMus-1].prenom,
                      p_mus[NbMus-1].nom,
                     &p_mus[NbMus-1].date.date_naiss,
                     &p_mus[NbMus-1].date.date_mort );
    free( buffer );
    fread( &ind, sizeof(INDEX), 1, index );
  }
  /* Fermeture des fichiers. */
  fclose( index ); fclose( mus );
  /* Affichage de la liste des musiciens. */
  printf( "\n\n\t\tListe des musiciens :\n" );
  printf( "\t\t-------------------\n\n" );
  imprime( p_mus, NbMus );
  /*
   * Tri puis affichage de la liste des musiciens
   * triés par ordre alphabétique.
   */
  qsort( p_mus, NbMus, sizeof(MUSICIEN), cmp_alpha );
  printf( "\n\n\tListe des musiciens"
          " par ordre alphabétique :\n" );
  printf( "\t-----------------------"
          "-------------------\n\n" );
  imprime( p_mus, NbMus );
  

  /*
   * Tri puis affichage de la liste des musiciens
   * triés par ordre chronologique.
   */
  qsort( p_mus, NbMus, sizeof(MUSICIEN), cmp_chrono );
  printf( "\n\n\tListe des musiciens"
          " par ordre chronologique :\n" );
  printf( "\t-----------------------"
          "---------------------\n\n" );
  imprime( p_mus, NbMus );

  /* Recherche du musicien mort le plus jeune. */
  mus_mort_le_plus_jeune =  mort_le_plus_jeune( p_mus, NbMus );
  /*
   * Affichage du musicien mort le plus jeune, ainsi
   * que sa durée de vie.
   */
  printf( "\n\n\tLe musicien mort le plus jeune est :"
          "\n\t----------------------------------\n\n" );
  printf( "\t%s %s qui est mort a %d ans.\n\n",
           mus_mort_le_plus_jeune.prenom,
           mus_mort_le_plus_jeune.nom,
           mus_mort_le_plus_jeune.date.date_mort -
           mus_mort_le_plus_jeune.date.date_naiss );

  printf( "\n\nFin EXO16.\n" );

  return 0;
}
  

/*
 * Fonction appelée par "qsort" pour trier les
 * musiciens par ordre alphabétique.
 */
§MEVBCBfint cmp_alpha( const void *mus1, const void *mus2 )
{
  if( strcmp( ((MUSICIEN *)mus1)->nom,
              ((MUSICIEN *)mus2)->nom ) > 0 )
    return 1;
  if( strcmp( ((MUSICIEN *)mus1)->nom,
              ((MUSICIEN *)mus2)->nom) < 0 )
    return -1;
  return 0;
}

/*
 * Fonction appelée par "qsort" pour trier les
 * musiciens par ordre chronologique.
 */
§MEVBCBfint cmp_chrono( const void *mus1, const void *mus2 )
{
  if( ((MUSICIEN *)mus1)->date.date_naiss >
      ((MUSICIEN *)mus2)->date.date_naiss )
    return 1;
  if( ((MUSICIEN *)mus1)->date.date_naiss <
      ((MUSICIEN *)mus2)->date.date_naiss )
    return -1;
  return 0;
}
  

/* Fonction d'affichage. */
§MEVBCBfvoid imprime( MUSICIEN *mus, int n )
{
  int i;

  for( i=0; i

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

typedef struct index
{
  unsigned int debut;
  unsigned int longueur;
} INDEX;

§MEVBCBfint main( int argc, char **argv )
{
  void   erreur(int rc);
  void   usage (char *s);
  FILE  *index, *mus;
  int    rang_mus;
  INDEX  ind;
  char  *buffer;

  /* Le rang a-t-il été spécifié ? */
  if( argc != 2 ) usage( argv[0] );
  /* Conversion de l'argument en entier. */
  rang_mus = (int)strtol( argv[1], NULL, 0 );
  if( rang_mus <= 0 )
    erreur( 1 );
  /* Ouverture du fichier indexé des musiciens. */
  if( (index = fopen( "index", "r" )) == NULL )
    perror( "fopen" ), exit(2);
  /* Ouverture du fichier d'index. */
  if( (mus = fopen( "indmus", "r" )) == NULL )
    perror( "fopen" ), exit(3);
  

  /*
   * Positionnement dans le fichier d'index.
   * Ne pas trop compter sur la valeur retournée
   * par la fonction "fseek". Un mauvais positionnement
   * provoquera une erreur lors de la lecture suivante.
   */
  fseek( index, (rang_mus-1)*sizeof(INDEX), SEEK_SET );
  /*
   * Lecture de l'index contenant le positionnement et
   * la longueur de l'enregistrement, dans le fichier
   * indexé des musiciens, correspondant au rang spécifié.
   */
  if( fread( &ind, sizeof ind, 1, index ) != 1 )
    erreur( 4 );
  /*
   * Positionnement puis lecture
   * de l'enregistrement désiré.
   */
  fseek( mus, ind.debut, SEEK_SET );
  buffer = malloc( ind.longueur+1 );
  fgets( buffer, ind.longueur+1, mus );
  /* Affichage du musicien sélectionné. */
  printf( "\n\tmusicien de rang %d ==> %s\n\n",
           rang_mus, buffer );
  free( buffer );
  /* Fermeture des fichiers. */
  fclose( index ); fclose( mus );

  printf("\n\nFin EXO17.\n");

  return 0;
}
  

§MEVBCBfvoid erreur( int rc )
{
  fprintf( stderr, "rang invalide.\n" );
  exit( rc );
}

§MEVBCBfvoid usage( char *s )
{
  fprintf( stderr, "usage : %s rang\n", s );
  exit( 6 );
}
  

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <fcntl.h>

int    *positions;
int     nb_positions;
size_t  taille_bloc;

§MEVBCBfstatic void init( size_t longueur )
{
  positions = NULL;
  nb_positions = 0;
  taille_bloc = BUFSIZ - longueur + 1;

  return;
}

§MEVBCBfint main( int argc, char **argv )
{
   void  usage(char *s);
   void  strrech( char *buffer, int nblus,
                  char *ChaineAchercher, size_t longueur );
   int     fd;
   char    buffer[BUFSIZ];
   char   *ChaineAchercher;
   size_t  longueur;
   int     nblus;
  

   /*
    * Le fichier et la chaîne à chercher
    * ont-ils été passés en argument ?
    */

   if ( argc != 3 )
     usage( argv[0] );
   ChaineAchercher = argv[2];
   longueur = strlen( ChaineAchercher );

   /*
    * initialisation des variables globales.
    */
   init( longueur );

   /* Ouverture du fichier passé en argument. */

   if( (fd = open( argv[1], O_RDONLY )) == -1 )
   {
      perror( "open" );
      exit( 1 );
   }
  

   /* Boucle de lecture du fichier. */

   while( nblus = read( fd, buffer, sizeof buffer ) )
   {
     /*
      * Récupération des positions de la chaîne
      * dans le buffer courant.
      */

     strrech( buffer, nblus, ChaineAchercher, longueur );

     /*
      * Si BUFSIZ caractères ont été lus, on
      * recule de (longueur-1) caractères
      * dans le fichier, pour être sûr de n'oublier
      * aucune position de la chaîne.
      */

     if( nblus == BUFSIZ )
       lseek( fd, -(long)(longueur - 1), SEEK_CUR );
   }
   close( fd );

   /* Impression des positions trouvées. */

   if ( nb_positions == 0 )
     printf( "La chaîne \"%s\" n'a pas été trouvée\n"
             "dans le fichier \"%s\".\n",
              ChaineAchercher, argv[1] );
  

   else
   {
     int pos;

     printf( "Dans le fichier \"%s\", la chaîne \"%s\"\n"
             "a été trouvée aux positions :\n\n",
              argv[1], ChaineAchercher );
     for( pos=0; pos

/*
 * Fonction de récupération des positions
 * de la chaîne dans le buffer courant.
 */

§MEVBCBfvoid strrech( char *s, int nblus,
              §MEVBCBfchar *ChaineAchercher, size_t longueur )
{
   char       *buffer, *ptr;
   static int  n = 0, nombre_octets_lus = 0;
   int         i;

   /*
    * On prend garde de remplacer les éventuels caractères
    * "nuls" par des blancs pour pouvoir utiliser
    * la fonction "strstr".
    */

   buffer = malloc( nblus+1 );
   memcpy( buffer, s, nblus );
   for( i=0; i

   /* Boucle de recherche de la chaîne. */

   for( ptr=buffer;
        ptr=strstr( ptr, ChaineAchercher );
        ptr+=longueur )
   {
     /*
      * extension du vecteur positions.
      */

     positions = (int *)realloc( positions, ++n*sizeof(int) );
     assert( positions != NULL );

     /*
      * position de la chaîne trouvée par
      * rapport au début du bloc lu.
      */

     positions[n-1] = ptr - buffer + 1;

     /*
      * position de la chaîne trouvée par
      * rapport au début du fichier.
      */

     positions[n-1] += nombre_octets_lus;
   }
   free( buffer );
  

   /*
    * Nombre d'octets déjà lus dans le fichier.
    */

   nombre_octets_lus += taille_bloc;
   nb_positions = n;

   return;
}

§MEVBCBfvoid usage(char *s)
{
   fprintf( stderr, "usage: %s fichier"
                    " ChaineAchercher.\n", s );
   exit(1);
}
  

#define taille(t) sizeof(t) / sizeof(t[0])
typedef enum bool {False, True} Boolean;
  

void ajouts     ( void );
void liste      ( void );
void tri        ( void );
void suppression( void );
void vider      ( void );
void arret      ( void );
  

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "exo19.h"
#include "exo19_gestion_liste.h"

struct menu
{
  char  *texte;
  void (*action)( void );
};

§MEVBCBfint main()
{
  /* Définition du menu. */
  struct menu menu[] =
  {
    {"  1 - AJOUTS d'éléments dans une liste chaînée.\n",
                                                 ajouts},
    {"  2 - AFFICHAGE de la liste chaînée.\n",
                                                  liste},
    {"  3 - TRI de la liste chaînée.\n",
                                                    tri},
    {"  4 - SUPPRESSION d'éléments dans la liste.\n",
                                            suppression},
    {"  5 - VIDER la liste.\n",
                                                  vider},
    {"  6 - ARRÊT du programme.\n",
                                                  arret}
  };
  

  int SelectionMenu( struct menu menu[], int NbChoix );

  /* Boucle infinie sur les choix effectués. */
  for (;;)
    menu[SelectionMenu( menu, taille(menu) )].action();
}
  

/* Fonction renvoyant le choix effectué. */

§MEVBCBfint SelectionMenu( struct menu menu[], int NbChoix )
{
  int   choix, m;
  char  entree[10];
  char *endp;

  do
  {
    printf( "\n\nListe des choix :\n" );
    for( m=0; m NbChoix )
      printf( "\nERREUR - choix invalide.\n" );
  } while( *endp != '\0' ||
           choix < 1 || choix > NbChoix );
  printf("\n");

  return --choix;
}
  

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "exo19.h"
#include "exo19_gestion_liste.h"

#define LISTE_VIDE "La liste est vide.\n"

static const char * const prompt_ajout       =
     "Élément à ajouter[CtrlD pour terminer] --> ";
static const char * const prompt_suppression =
     "Élément à supprimer[CtrlD pour terminer] --> ";
static const char *prompt;

typedef struct cellule
{
  char           *capitale;
  struct cellule *ptr_precedent;
  struct cellule *ptr_suivant;
} CEL;

static CEL  *debut   = NULL;
static CEL  *curseur = NULL;

static Boolean  liste_vide( void );
static void     ajout_cellule( char *chaine );
static void     suppression_cellule( void );
static Boolean  recherche_cellule( char *chaine );
static char    *lire_chaine( void );
static void     affichage_liste( CEL *p );
  

§MEVBCBfstatic Boolean liste_vide( void )
{
  return debut == NULL ? True : False;
}

§MEVBCBfstatic void ajout_cellule( char *chaine )
{
  CEL *p;

  /*
   * Allocation, valorisation,
   * insertion du nouvel élément.
   */

  p = malloc( sizeof(CEL) );
  p->capitale = chaine;

  if ( liste_vide() )
    p->ptr_suivant = p->ptr_precedent = NULL;
  else
  {
    if ( curseur != debut )
      curseur->ptr_precedent->ptr_suivant = p;
    p->ptr_precedent = curseur->ptr_precedent;
    curseur->ptr_precedent = p;
    p->ptr_suivant = curseur;
  }
  curseur = p;
  if( curseur->ptr_precedent == NULL )
    debut = curseur;

  return;
}
  

§MEVBCBfstatic void suppression_cellule( void )
{
  if( curseur == debut )
  {
    /*
     * L'élément à supprimer est le 1er de la liste.
     */

    debut = curseur->ptr_suivant;
    if( ! liste_vide() )
      debut->ptr_precedent = NULL;
  }
  else
  {
    /*
     * L'élément à supprimer n'est pas le 1er de la liste.
     */

    curseur->ptr_precedent->ptr_suivant =
                          curseur->ptr_suivant;
    if( curseur->ptr_suivant != NULL )
      /*
       * L'élément à supprimer n'est
       * pas le dernier de la liste.
       */
      curseur->ptr_suivant->ptr_precedent =
                          curseur->ptr_precedent;
  }
  

  {
    CEL *p = curseur;

    free( p->capitale ); free( p );
    if ( curseur->ptr_suivant != NULL )
      curseur = curseur->ptr_suivant;
    else
      curseur = debut;
  }

  return;
}

§MEVBCBfstatic Boolean recherche_cellule( char *chaine )
{
  CEL *p;

  for( p=debut; p; p=p->ptr_suivant )
    if ( ! strcmp( p->capitale, chaine ) )
      break;

  if( p != NULL )
  {
    curseur = p;
    return True;
  }

  return False;
}
  

§MEVBCBfstatic char *lire_chaine( void )
{
  char buffer[BUFSIZ];

  /*
   * Lecture de l'élément à ajouter.
   */

  fputs( prompt, stdout );
  gets( buffer );

  /*
   * Si Control-D, annuler le bit indicateur
   * de fin de fichier, pour les prochaines saisies.
   */

  if( feof( stdin ) )
  {
    clearerr( stdin );
    return NULL;
  }

  return strdup( buffer );
}
  

/*
 * Fonction rattachée au choix 1.
 * (AJOUTS d'éléments dans la liste chaînée).
 */

§MEVBCBfvoid ajouts( void )
{
  char *chaine;

  /*
   * Boucle de lecture des chaînes.
   */

  prompt = prompt_ajout;

  while( (chaine = lire_chaine()) != NULL )
    ajout_cellule( chaine );

  return;
}
  

/*
 * Fonction rattachée au choix 3.
 * (TRI de la liste chaînée).
 */

§MEVBCBfvoid tri( void )
{
  Boolean  tri_terminee;
  CEL     *ptr;

  /*
   * La liste doit exister.
   */

  if ( liste_vide() )
    fprintf( stderr, LISTE_VIDE );
  else
  {
    /*
     * Boucle de tri.
     */
  

    do
    {
      tri_terminee = True;
      for( ptr=debut; ptr->ptr_suivant;
           ptr = ptr->ptr_suivant )
        if( strcmp( ptr->capitale,
                    ptr->ptr_suivant->capitale ) > 0 )
        {
          /*
           * On effectue une interversion.
           */

          curseur = ptr;
          ajout_cellule(
            strdup( curseur->ptr_suivant->capitale ) );
          curseur = ptr->ptr_suivant;
          suppression_cellule();
          tri_terminee = False;
          if ( ptr->ptr_suivant == NULL )
            break;
        }
    } while( ! tri_terminee );
  }

  return;
}
  

/*
 * Fonction rattachée au choix 4.
 * (SUPPRESSION d'éléments dans la liste).
 */
§MEVBCBfvoid suppression( void )
{
  char *chaine;

  /*
   * Boucle de lecture des chaînes.
   */
  prompt = prompt_suppression;

  while( ! liste_vide() && (chaine = lire_chaine()) != NULL )
  {
    if( ! recherche_cellule( chaine ) )
    {
      fprintf( stderr, "L'élément \"%s\" est"
                       " inexistant!\n\n", chaine );
      continue;
    }
    suppression_cellule();
    printf( "L'élément \"%s\" a été supprimé"
            " de la liste.\n\n", chaine );
  }

  /*
   * La liste est-elle vide ?
   */
  if ( liste_vide() ) fprintf( stderr, LISTE_VIDE );

  return;
}
  

/*
 * Fonction rattachée au choix 5.
 * (VIDER la liste ).
 */
§MEVBCBfvoid vider( void )
{
  if ( liste_vide() )
    fprintf( stderr, LISTE_VIDE );
  else
  {
    curseur = debut;
    while ( ! liste_vide() )
      suppression_cellule();
  }

  return;
}
/*
 * Fonction rattachée au choix 6.
 * (ARRET du programme).
 */
§MEVBCBfvoid arret( void )
{
  /*
   * Si la liste n'est pas vide, on libère
   * la mémoire qu'elle occupe.
   */
  if( ! liste_vide() ) vider();

  printf( "\n\nFin EXO19.\n" );

  exit( 0 );
}