Exercices en langage C/Fonctions

Exercices en langage C

• Préparation
• Notions de base
• Les variables et constantes
• Les types
• Les opérateurs
• Les structures de contrôle
• Les tableaux statiques
• Les fonctions
• Les chaînes de caractères
• Les pointeurs
• Le préprocesseur C

Ces exercices concernent l'utilisation des fonctions de la bibliothèque standard du langage C.

Filtre qui passe le texte en majuscule

Problème à résoudre

Écrivez un programme majuscule.c qui lit des données sur le flux stdin et écrits sur stdout après avoir transformé les caractères lus en majuscules. Vous utiliserez les fonctions getchar, putchar (stdio.h) et toupper (ctype.h).

Vous testerez votre programme en lui faisant convertir son propre fichier source majuscule.c.

majuscule.exe < majuscule.c

Solution proposée

Solution proposée

/**
 * Programme . : majuscule
 * Rôle ...... : convertit les caractères lus sur stdin en majuscule.
 * Paramètres : Aucun
 * Compilation et EDL : gcc -Wall -o majuscule.exe majuscule.c
 *	Auteur ...... : Thierry46
 *	Version ..... : 1.0 du 4/2/2008
 *	Licence ..... : GNU GPL.
 */

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

int main(void)
{
	int c;
	while ((c=getchar()) != EOF)
	{
		(void)putchar(toupper(c));
	}

	return EXIT_SUCCESS;
}

Lire une ligne longue avec fgets

Problème à résoudre

La fonction fgets de la bibliothèque standard du langage C permet de lire une chaîne de caractère de longueur limitée dans un flux.

Vous allez compléter une fonction lire_ligne répondant au spécifications suivantes :

• Retour d'une ligne lue dans un flux texte passé en paramètre.
• Vous éliminerez les caractères de saut de ligne lus.
• La longueur des lignes lues n'est pas limitée.
• Contrôle des paramètres et retour des codes d'erreurs systèmes, détection de la fin du fichier.
• Vous utiliserez au maximum les fonctions de la bibliothèque standard du langage C : allocation mémoire, chaînes de caractères...
• Son prototype est donné par lire_ligne.h.
• Vous utiliserez le programme de main_lire_ligne.c pour lire_ligne.
• Vous devrez traiter le fichier test_lire_ligne.txt fourni.
• Les instructions de compilation et d'édition de lien sont dans les commentaires des fichiers fournis.

Éléments fournis

lire_ligne.c à compléter

/**
 * Fonction .. : lire_ligne
 * Rôle ...... : tente de lire une ligne entière depuis le flux.
 *	- Le caractère de saut de ligne '\n' final est enlève.
 *	- L’appelant doit se charger de la désallocation de la chaîne retournée.
 *
 * Paramètres :
 *	- pChaine : adresse de retour de la chaîne
 *	- tailleBufferLecture : taille du buffer de lecture,
 *		dans la pratique on pourra choisir _POSIX_MAX_INPUT (ref limits.h).
 *	- flux : un pointeur sur le descripteur du fichier a lire.
 *
 *	- Valeur retournée :
 *		- Si OK : EXIT_SUCCESS.
 *		- Si Fin de fichier atteinte sans rencontrer \n : EOF,
 *			- la chaîne retournée contient le début de la ligne longue.
 *			- Si rien a lire, retour d'un pointeur NULL pour la chaîne.
 *		- En cas de problème : Le code d'erreur système utilisable par perror.
 *			et retour d'un pointeur NULL pour la chaîne.
 *
 * Auteur ...... : Votre nom
 * Version ..... : 1.0 du date
 * Licence ..... : GNU GPL.
    lire_ligne : Lecture d'une ligne longue dans un fichier texte
    Copyright (C) 2008  Thierry46

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Compilation . : gcc -pedantic -Wall -std=c99 -c lire_ligne.c
 * Fichiers lies : main_lire_ligne.c, lire_ligne.h
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>
#include <errno.h>
#include "lire_ligne.h"

/*@null@*/ char *lire_ligne(size_t tailleBufferLecture,
	FILE * restrict flux, int *pCodeRetour)
{
// Début partie à compléter...
// Fin partie à compléter...
} // char *lire_ligne(...

lire_ligne.h

/*
 *  Nom .... : lire_ligne.h
 *  Rôle ... : Définitions et prototype de lire_ligne.h
 * Auteur ...... : Thierry46
 * Version ..... : 1.0 du 30/1/2008
 * Licence ..... : GNU GPL.
    lire_ligne : Lecture d'une ligne longue dans un fichier texte
    Copyright (C) 2008  Thierry46

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Fichier lie : lire_ligne.c
 */
#ifndef LIRE_LIGNE_H
#define LIRE_LIGNE_H

extern /*@null@*/ char *lire_ligne(size_t tailleBufferLecture,
	FILE * restrict flux, int *pCodeRetour);

#endif

main_lire_ligne.c

/*
 *  Nom ......... : main_lire_ligne.c
 *  Rôle ........ : Tester la fonction lire_ligne
 *  Paramètre ... : Aucun
 *  Code retour . : EXIT_SUCESSS (0)
 *  Auteur ...... : Thierry46
 *  Version ..... : 1.1 du 4/2/2008
 *  Licence ..... : GNU GPL.
    lire_ligne : Lecture d'une ligne longue dans un fichier texte
    Copyright (C) 2008  Thierry46

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Compilation . : 
 *   Voir lire_ligne .c pour sa compilation
 *   gcc -pedantic -Wall -std=c99 -o test_lire_ligne.exe main_lire_ligne.c lire_ligne.o
 * Exécution : ./test_lire_ligne.exe
 * Fichiers lies : lire_ligne.c, lire_ligne.h, test_lire_ligne.txt
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lire_ligne.h"

#define FIC_TEST "test_lire_ligne.txt"
// Valeur faible de TAILLE_BUFFER pour test débordements et lecture multiple.
#define TAILLE_BUFFER (size_t)10
#define TAILLE_MAX_MESSAGE 256

int main(void)
{
   FILE *hFicTest = NULL;
   char *chaine = NULL;
   int numLigne = 1;
   int retour = EXIT_SUCCESS;
   char message[TAILLE_MAX_MESSAGE];
   
   hFicTest = fopen(FIC_TEST, "r");
   if (hFicTest == NULL)
   {
      (void)printf("%s : le fichier %s n'a pas pu être ouvert !\n",
         __func__, FIC_TEST);
      // Je laisse poursuivre pour tester assertion dans lire_ligne. //
   }
   
   do
   {
      chaine = lire_ligne(TAILLE_BUFFER, hFicTest, &retour);
      if (retour == EXIT_SUCCESS)
      {
         (void)strncpy(message, "Pas d'erreur", sizeof(message) - 1);
      }
      else if (retour == EOF)
      {
         (void)strncpy(message, "Fin de fichier", sizeof(message) - 1);
      }
      else
      {
         (void)strncpy(message, strerror(retour), sizeof(message) - 1);
      }
      message[sizeof(message) - 1] = '\0';
      
      (void)printf("Ligne %d : retour = %d (%s), chaîne lue = \"%s\".\n",
         numLigne, retour, message,
         (chaine == NULL) ? "! Pointeur NULL !" : chaine);

      free(chaine);
      chaine = NULL;
   } while (retour == EXIT_SUCCESS);
   
   if (hFicTest != NULL)
   {
      (void)fclose(hFicTest);
   }
   
   return EXIT_SUCCESS;
} // int main(void)

test test_lire_ligne.txt

1
1234567880
ligne longue.

12345678901234567890123456789012345678901234567890
fin

Solution proposée

Voir la solution

/**
 * Fonction .. : lire_ligne
 * Rôle ...... : tente de lire une ligne entière depuis le flux.
 * - Le caractère de saut de ligne '\n' final est enleve.
 * - L’appelant doit se charger de la désallocation de la chaîne retournée.
 *
 * Paramètres :
 * - pChaine : adresse de retour de la chaîne
 * - tailleBufferLecture : taille du buffer de lecture,
 *   dans la pratique on pourra choisir _POSIX_MAX_INPUT (ref limits.h).
 * - flux : un pointeur sur le descripteur du fichier a lire.
 *
 * - Valeur retournée :
 *    - Si OK : EXIT_SUCCESS.
 *    - Si Fin de fichier atteinte sans rencontrer \n : EOF,
 *       - la chaîne retournée contient le début de la ligne longue.
 *       - Si rien a lire, retour d'un pointeur NULL pour la chaîne.
 *       - En cas de problème : Le code d'erreur système utilisable
 *         par perror et retour d'un pointeur NULL pour la chaîne.
 *
 * Auteur ...... : Thierry46
 * Version ..... : 1.1 du 4/2/2008
 * Licence ..... : GNU GPL.
    lire_ligne : Lecture d'une ligne longue dans un fichier texte
    Copyright (C) 2008  Thierry46
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Compilation . : gcc -pedantic -Wall -std=c99 -c lire_ligne.c
 * Fichiers lies : main_lire_ligne.c, lire_ligne.h
 *
 * Remarques : 
 * - Beaucoup de commentaires sont présents pour un usage didactique.
 * - Ce programme utilise une syntaxe specifique C99.
 * - Ce programme a ete controle avec l'outil de verification statique
 * - Splint v3.1.2 du 19 Jan 2008 : <http://www.splint.org/>
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>
#include <errno.h>
#include "lire_ligne.h"
 
/*@null@*/ char *lire_ligne(size_t tailleBufferLecture,
        FILE * restrict flux, int *pCodeRetour)
{
   // Declarations
   char *chaineRetour = NULL;
   bool litEncore = true;
   bool rienLu = true;
   int codeRetour = EXIT_SUCCESS;
 
   // Controle rapide des parametres.
   // Si quelque chose ne va pas, arret.
   assert(tailleBufferLecture > 0);
   assert(flux != NULL);
 
   // On reinitialise errno
   errno = 0;
 
   // Boucle de lecture d'une ligne eventuellement longue
   do
   {
      size_t positionEcriture;
      char *nouvelleChaine;
      litEncore = false;
 
      // Demande d'une nouvelle zone memoire
      positionEcriture =
         (chaineRetour == NULL) ? 0 : strlen(chaineRetour);
      nouvelleChaine = realloc(chaineRetour,
         positionEcriture + tailleBufferLecture);
      if (nouvelleChaine == NULL) // Si probleme d'allocation
      {
         codeRetour = errno;
         free(chaineRetour);
         chaineRetour = NULL;
      }
      else // Si le systeme a accorde la memoire
      {
         chaineRetour = nouvelleChaine;
          if (fgets(chaineRetour+positionEcriture,
            (int)tailleBufferLecture, flux)
            != NULL)
         {
            // Recherche si un \n a ete lu en fin de chaine.
            char *positionNewLine = strrchr(chaineRetour, '\n');
            rienLu = false;
            if (positionNewLine != NULL)
            {
               // Suppression du caractere de fin de ligne \n,
               *positionNewLine = '\0';
            }
            else // fgets n'a pas pu lire la ligne complete.
            {
               litEncore = true;
            }
         } else if (ferror(flux) != 0)
         {
            codeRetour = errno;
            free(chaineRetour);
            chaineRetour = NULL;
         } else if (feof(flux) != 0)
         {
            codeRetour = EOF;
            if (rienLu)
            {
               free(chaineRetour);
               chaineRetour = NULL;
            }
         }
      }  // else if (nouvelleChaine == NULL)
   } while (litEncore);
 
   // Retour des resultats. 
   *pCodeRetour = codeRetour;
   return chaineRetour;
} // char *lire_ligne(...

Remarques sur l'exercice

• Le test des paramètres dans la solution est expéditif.
• Pour obtenir des programmes robustes, le langage C oblige à une gestion pénible des erreurs. Avec le langage Java par exemple, les mécanismes d'exception facilitent la tâche du programmeur.
• L'utilisation de l'allocation dynamique de mémoire est risquée : fuite mémoire. Avec le langage Java par exemple, le ramasse miettes (Garbage collector) se charge de la libération de la mémoire.
• En Java des classes comme String et StringBuffer prennent en charge les chaines de caractères longues.

Test d'un générateur de nombre aléatoire

Problème à résoudre

La bibliothèque standard du langage C offre au programmeur plusieurs fonctions pour générer des nombres aléatoires. La plus connue est rand().

Vous allez écrire un programme verifrand.c qui estime la répartition des nombres aléatoires générés : moyenne et dispersion. Nous allons traiter l'ensemble des nombres générés comme une série discrète regroupée.

1. Générez 1 million (NB_TIRAGE) notes (x_i) entre 0 et 20 (N) comprises (NB_NOTE = 21) à l'aide de la fonction rand().
2. Répartissez-les dans le tableau effectif (n) où n_i représente l'effectif (nombre d'occurrences cumulées) de la note x_i.
3. calculez et affichez la moyenne arithmétique : ${\overline {x}}={\frac {\sum _{i=0}^{N}(n_{i}*x_{i})}{\sum _{i=0}^{N}n_{i}}}={\frac {\sum _{i=1}^{N}(n_{i}*i)}{NB\_TIRAGE}}$
4. calculez et affichez l'écart moyen de la série : $Em={\frac {\sum _{i=0}^{N}(n_{i}*|x_{i}-{\overline {x}}|)}{\sum _{i=0}^{N}n_{i}}}={\frac {\sum _{i=1}^{N}(n_{i}*|i-{\overline {x}}|)}{NB\_TIRAGE}}$

Solution proposée

Voir la solution

/*
 Nom : verifrand.c
 Auteur : Thierry46
 Role : Verifier generateur de nombre aleatoire
 Licence : GNU GPL
 Version : 1.0 du 17/2/2008
 Compilation : gcc -Wall -pedantic -std=c99 -o verifrand.exe verifrand.c
 */

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

//  NB_NOTE est appele N dans les formules
// 20 notes : de 0 à 20 inclus
#define NB_NOTE 21
#define NB_TIRAGE 1000000UL

int main(void)
{
   unsigned long effectif[NB_NOTE];// appele n dans les formules
   unsigned short note; // appelee i dans les formules, ici xi = i 
   double moyenne; // appelee x barre dans les formules
   double ecartMoyen;
   unsigned long numTirage;
   unsigned short noteLaMoinsGeneree;
   unsigned short noteLaPlusGeneree;
   
   // Init a 0 du tableau des nombres d'occurence
   for (note=0; note<NB_NOTE; note++)
   {
      effectif[note] = 0;
   }

   // Generation des nombres aleatoires
   (void)printf("Generation et repartition %lu notes dans tableau effectif.\n",
      NB_TIRAGE);
   for (numTirage=0; numTirage<NB_TIRAGE; numTirage++)
   {
      effectif[rand()%NB_NOTE]++; 
   }

   // Determination des notes les moins et les plus generees
   for (note=1, noteLaMoinsGeneree=0, noteLaPlusGeneree=0; note<NB_NOTE; note++)
   {
      if (effectif[note] < effectif[noteLaMoinsGeneree])
      {
         noteLaMoinsGeneree = note;
      }
      if (effectif[note] > effectif[noteLaPlusGeneree])
      {
         noteLaPlusGeneree = note;
      }
   }
   (void)printf("Note la moins generee : %hu (%lu fois)\n"
                "Note la plus generee : %hu (%lu fois)\n",
                noteLaMoinsGeneree, effectif[noteLaMoinsGeneree],
                noteLaPlusGeneree, effectif[noteLaPlusGeneree]);
   
   // Calcul de la moyenne de la série
   for (note=0, moyenne=0.0; note<NB_NOTE; note++)
   {
      moyenne += (double)effectif[note]*(double)note;
   }
   moyenne /= (double)NB_TIRAGE;
   (void)printf("La moyenne = %lf\n", moyenne);
   
   // Estimation de l'écart moyen de la série
   for (note=0, ecartMoyen=0; note<NB_NOTE; note++)
   {
      ecartMoyen += (double)effectif[note]*fabs((double)note - moyenne);
   }
   ecartMoyen /= (double)NB_TIRAGE;
   (void)printf("ecart moyen = %lf\n", ecartMoyen);
   
   return EXIT_SUCCESS;
} // int main(void)

Résultats obtenus :

MacMini-TM:~/Documents/c thierry$ ./verifrand.exe
Generation et repartition des 1000000 notes dans tableau effectif.
Note la moins generee : 14 (47263 fois)
Note la plus generee : 6 (48047 fois)
La moyenne = 9.991110
ecart moyen = 5.236995

Remarques sur l'exercice

• La série générée avec rand() sur ma machine est bien centrée sur la moyenne théorique 10/20 : les nombres de notes en dessous et au dessus de 10 sont quasi-identiques. L'écart moyen de la série est proche de 5 ce qui indique que les notes sont bien réparties.
• La fonction rand() est pseudo-aléatoire : deux exécutions du programme donnent exactement la même série de note.
• Vous pouvez tester d'autres fonctions comme random() ou arc4random(). Cette dernière, de qualité cryptographique, utilise l'algorithme nommé ARC4. Elle est aléatoire.