Différences entre les versions de « Exercices en langage C/Fonctions »

→‎Solution proposée : Simplification malloc -> realloc(NULL, suppresion tabulation.
(Ajout Exercice majuscules)
(→‎Solution proposée : Simplification malloc -> realloc(NULL, suppresion tabulation.)
 
===Solution proposée===
<div style="width:7080%">{{Boîte déroulante|titre=Voir la solution|contenu =
<source lang="c">
/**
* Fonction .. : lire_ligne
* Role ...... : tente de lire une ligne entiere depuis le flux.
* - Le caractere de saut de ligne '\n' final est enleve.
* - L'appellant doit se charger de la desallocation de la chaine retournee.
*
* Parametres :
* - pChaine : adresse de retour de la chaine
* - 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 retournee :
* - Si OK : EXIT_SUCCESS.
* - Si Fin de fichier atteinte sans rencontrer \n : EOF,
* - la chaine retournée contient le debut de la ligne longue.
* - Si rien a lire, retour d'un pointeur NULL pour la chaine.
* - En cas de probleme : Le code d'erreur systeme utilisable par perror.
* par perror et retour d'un pointeur NULL pour la chaine.
*
* Auteur ...... : Thierry46
* Version ..... : 1.01 du 304/12/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/>.
*
* 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 <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, cela ne sert à rien d'aller plus loinarret.
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;
litEncore = false;
// Si 1ere lecture : demande d'une nouvelle zone memoire
// Demande d'une nouvelle zone memoire
if (chaineRetour == NULL)
positionEcriture =
{
(chaineRetour == NULL) ? 0 : strlen(chaineRetour);
positionEcriture = 0;
nouvelleChaine = realloc(chaineRetour,
chaineRetour = malloc(tailleBufferLecture);
positionEcriture + tailleBufferLecture);
if (chaineRetour == NULL)
if (nouvelleChaine == NULL) // Si probleme d'allocation
{
{
codeRetour = errno;
codeRetour = errno;
}
free(chaineRetour);
}
chaineRetour = NULL;
else // Pour les lectures suivantes : extension de la zone memoire
}
{
else // Si le systeme a accorde la memoire
char *nouvelleChaine;
{
positionEcriture = strlen(chaineRetour);
chaineRetour = nouvelleChaine;
nouvelleChaine = realloc(chaineRetour, positionEcriture + tailleBufferLecture);
if (fgets(chaineRetour+positionEcriture,
if (nouvelleChaine == NULL)
(int)tailleBufferLecture, flux)
{
!= NULL)
codeRetour = errno;
{
free(chaineRetour);
// Recherche si un \n a ete lu en fin de chaine.
chaineRetour = NULL;
char *positionNewLine = strrchr(chaineRetour, '\n');
}
rienLu = false;
else
if (positionNewLine != NULL)
{
{
chaineRetour = nouvelleChaine;
// Suppression du caractere de fin de ligne \n,
}
*positionNewLine = '\0';
} // if (chaineRetour == NULL)
}
 
else // fgets n'a pas pu lire la ligne complete.
// Si le systeme a accorde la memoire, lecture d'une chaine par fgets
{
if (chaineRetour != NULL)
litEncore = true;
{
}
if (fgets(chaineRetour+positionEcriture, (int)tailleBufferLecture, flux)
} else if (ferror(flux) != 0)
!= NULL)
{
{
codeRetour = errno;
// Recherche si un \n a ete lu en fin de chaine.
char *positionNewLine = strrchr free(chaineRetour, '\n');
chaineRetour = NULL;
rienLu = false;
} else if (positionNewLinefeof(flux) != NULL0)
{
{
codeRetour = EOF;
// Suppression du caractere de fin de ligne \n,
if (rienLu)
*positionNewLine = '\0';
{
}
free(chaineRetour);
else // fgets n'a pas pu lire la ligne complete.
chaineRetour = NULL;
{
}
litEncore = true;
}
}
} // else if (nouvelleChaine == NULL)
}
} while (litEncore);
else if (ferror(flux) != 0)
{
// Retour des resultats.
codeRetour = errno;
*pCodeRetour = codeRetour;
free(chaineRetour);
return chaineRetour;
chaineRetour = NULL;
} else if (feof(flux) != 0)
{
codeRetour = EOF;
if (rienLu)
{
free(chaineRetour);
chaineRetour = NULL;
}
}
} // if (chaineRetour != NULL)
} while (litEncore);
// Retour des resultats.
*pCodeRetour = codeRetour;
return chaineRetour;
} // char *lire_ligne(...
</source>
227

modifications