(Plus de détails sur mon site :
http://perso.orange.fr/beorn/progra_c/file_dynamique.html )
Les fichiers file.c et file.h forment une bibliothèque permettant de gérer des files statiques.
Le type utilisé pour les files est "file_t".
La file est dite statique car elle stocke ses éléments dans un tableau dont la taille est définie. La file possède donc un nombre d'éléments maximal.
Les différentes fonctions sont :
- vide : vaut 1 si la file est vide, 0 sinon
- init : alloue une file en mémoire (le paramètre de cette fonction est la taille d'allocation des tableaux/sections de la file) et renvoie son adresse
- enfile : permet d'enfiler un nouvel élément sur la pile
- defile : défile le premier élément rajouté (renvoie 1 si la file est vide, 0 sinon)
- supprime : libère tout l'espace mémoire utilisé par une file
Plus de précisions dans les commentaires... :-)
Vous trouverez dans le .zip un petit main.c utilisant la bibliothèque et faisant deux ou trois manipulations élémentaires...
Pour ceux qui utilisent Dev-C++, vous avez même le fichier .dev correspondant.
Source / Exemple :
file.h :
#ifndef _file_h_
#define _file_h_
#include <stdlib.h>
typedef int variant; /* remplacer int par le type de donnees a enfiler */
/*---------------- STRUCTURE DE FILE.C ---------------------------------------------*/
/*
Structure :
Nom : section
Fct : structure definisssant une section d'elements de type "variant"
typedef struct section
{
variant * tab; /* tableau representant la section proprement dite */
struct section * suiv; /* pointeur sur la section suivante */
struct section * prec; /* pointeur sur la section precedente */
} section_t;
/*
Structure :
Nom : file
Fct : structure definissant une file d'elements de type "variant"
typedef struct file
{
int a; /* indice de debut de la file : premier element a sortir */
int b; /* indice de fin de la file : dernier element a sortir */
int pas; /* nombre d'elements dans une section de file */
section_t * tete; /* pointeur de tete de la file */
section_t * sect; /* pointeur sur la dernière section de la file */
} file_t;
/*---------------- FONCTIONS DE FILE.C ---------------------------------------------*/
/*
Nom : vide
Fct : retourne un booleen indiquant si la file est vide
Entree : (f) adresse de la file
Sortie : booleen indiquant que la file est vide
unsigned short int vide(file_t * f);
/*
Nom : init
Fct : cree une nouvelle file et retourne son adresse
Entree : (maxi) nombre maximal d'elements de la file
Sortie : adresse de la nouvelle file
file_t * init(int maxi);
/*
Nom : enfile
Fct : enfile un nouvel element sur la file
Entree : (f) adresse de la file
(x) element a rajouter
Sortie : booleen indiquant que tout s'est bien passe
void enfile(file_t * f, variant x);
/*
Nom : defile
Fct : defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
Entree : (f) adresse de la file
(x) adresse de stockage de l'element defile
Sortie : booleen indiquant que tout s'est bien passe
unsigned short int defile(file_t * f, variant * x);
/*
Nom : supprime
Fct : libere toute la mémoire occupee par une file
Entree : (f) adresse de la file
void supprime(file_t * f);
#endif
file.c :
#include "file.h"
/*
Nom : vide
Fct : retourne un booleen indiquant si la file est vide
Entree : (f) adresse de la file
Sortie : booleen indiquant que la file est vide
unsigned short int vide(file_t * f)
{
return ((f->a) == -1); /* la pile est vide si a=-1 */
}
/*
Nom : init
Fct : cree une nouvelle file et retourne son adresse
Entree : (maxi) nombre maximal d'elements de la file
Sortie : adresse de la nouvelle file
file_t * init(int pas)
{
file_t * adr_file=NULL; /* l'adresse de la file est NULL si l'allocation echoue */
adr_file = (file_t *)malloc(sizeof(file_t)); /* adresse de la pile cree */
if ( adr_file )
{
adr_file->a = -1; /* aucun element dans la file */
adr_file->b = -1;
adr_file->pas = pas; /* nombre maximal d'elements */
adr_file->tete = NULL; /* la file est vide */
adr_file->sect = NULL; /* la file est vide */
}
return adr_file;
}
/*
Nom : enfile
Fct : enfile un nouvel element sur la file
Entree : (f) adresse de la file
(x) element a rajouter
Sortie : booleen indiquant que tout s'est bien passe
void enfile(file_t * f, variant x)
{
unsigned short int succes = 0;
if ( vide(f) ) /* si la file est vide */
{
f->tete = (section_t *)malloc(sizeof(section_t)); /* creation d'une premiere section */
f->sect = f->tete;
f->sect->tab = (variant *)malloc((f->pas) * sizeof(variant)); /* allocation de la premiere section */
f->sect->suiv = NULL; /* pas de section suivante */
f->sect->prec = NULL; /* pas de section precedente */
f->a = 0; /* le premier element est mis au debut du tableau */
f->b = 0; /* le dernier element est aussi le premier */
}
else
{
if( f->b == f->pas - 1 ) /* si la section est pleine */
{
f->sect->suiv = (section_t *)malloc(sizeof(section_t)); /* creation d'une nouvelle section */
f->sect->suiv->prec = f->sect; /* maj section precedente */
f->sect = f->sect->suiv; /* maj derniere section */
f->sect->tab = (variant *)malloc((f->pas) * sizeof(variant)); /* allocation de la derniere section */
f->sect->suiv = NULL; /* pas de section suivante */
f->b = 0; /* indice de fin a zero */
}
else
{
f->b = f->b + 1; /* incrementation de l'indice de fin */
}
}
- (f->sect->tab + f->b) = x; /* rajout du nouvel element sur la file */
}
/*
Nom : defile
Fct : defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
Entree : (f) adresse de la file
(x) adresse de stockage de l'element defile
Sortie : booleen indiquant que tout s'est bien passe
unsigned short int defile(file_t * f, variant * x)
{
unsigned short int succes = 0;
if ( !vide(f) ) /* si la file n'est pas vide */
{
- x = *(f->tete->tab + f->a); /* sortie du premier element rajoute */
if ( f->sect->prec != NULL ) /* s'il y a au moins deux sections */
{
if ( f->a != f->pas - 1 ) /* si la section ne doit pas disparaitre */
{
f->a = f->a + 1; /*incrementation de l'indice de debut*/
}
else
{
f->tete = f->tete->suiv; /* changement de la section de tete */
free(f->tete->prec); /* suppression de la section */
f->tete->prec = NULL; /* pas de section precedente */
f->a = 0; /* mise a zero de l'indice de debut */
}
}
else
{
if ( f->a != f->b ) /* si la file comporte au moins deux elements */
{
f->a = f->a + 1; /* incrementation de l'indice de debut */
}
else
{
free(f->tete); /* liberation de la section */
f->sect = NULL; /* raz du pointeur de derniere section */
f->a = -1; /* maintenant la file est vide */
f->b = -1;
}
}
succes = 1; /* marquage de la reussite */
}
return succes;
}
/*
Nom : supprime
Fct : libere toute la memoire occupee par une file
Entree : (f) adresse de la file
void supprime(file_t * f)
{
section_t * cour = f->tete, * suiv;
if ( cour != NULL ) /* s'il existe au moins une section */
{
suiv = f->tete->suiv;
while ( cour != NULL ) /* tant qu'il reste des sections non supprimees */
{
suiv = cour->suiv; /* progression du pointeur suivant */
free(cour->tab); /* liberation du contenu de la section courante */
free(cour); /* liberation de la section courante */
cour = suiv; /* progression du pointeur courant */
}
}
free(f); /* liberation de la structure pile */
}
Conclusion :
L'avantage par rapport aux files statiques est que si la file est pleine, de nouvelles portions de tableau sont allouées.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.