Bibliothèque de gestion de files statiques

Télécharger le projet
Commenter

Description

(Plus de détails sur mon site : http://perso.orange.fr/beorn/progra_c/file_statique.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
- pleine : vaut 1 si la file est pleine, 0 sinon
- init : alloue une file en mémoire (le paramètre de cette fonction est la taille maximale de la file) et renvoie son adresse
- enfile : permet d'enfiler un nouvel élément sur la pile (renvoie 1 si la pile est pleine, 0 sinon)
- 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	:	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 max;         /* nombre maximum d'elements de la file */
  variant * tete;  /* pointeur de tete 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	:	pleine
  Fct	:	retourne un booleen indiquant si la file est pleine
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est pleine


  • /


unsigned short int pleine(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 et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe


  • /


unsigned short int 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	:	pleine
  Fct	:	retourne un booleen indiquant si la file est pleine
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est pleine


  • /


unsigned short int pleine(file_t * f)
{
  return (((f->b)+1)%(f->max)) == (f->a); /* la pile est pleine si le dernier element precede le premier */
}

/*
  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)
{
  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->max = maxi;                        /* nombre maximal d'elements */
    adr_file->tete = (variant *)malloc(maxi * sizeof(variant)); /* allocation du tableau contenant les elements emfiles */
  }
  
  return adr_file;
}

/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe


  • /


unsigned short int enfile(file_t * f, variant x)
{
  unsigned short int succes = 0;
  
  if ( !pleine(f) ) /* si la file n'est pas pleine */
    {
      if ( vide(f) ) /* si la file est vide */
      {
        f->a = 0;  /* le premier element est mis au debut du tableau */
        f->b = 0;  /* le dernier element est aussi le premier */
      }
      else
      {
        f->b = (f->b + 1)%(f->max);  /* incrementation de l'indice de fin */
      }


         
  • (f->tete + f->b) = x; /* rajout du nouvel element sur la file */

      succes = 1;           /* marquage de la reussite */
    }
  
  return succes;
}

/*
  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 + f->a);     /* sortie du premier element rajoute */

      if ( f->a != f->b ) /* si la file comporte au moins un element */
      {
        f->a = (f->a + 1)%(f->max); /* incrementation de l'indice de debut */
      }
      else
      {
        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)
{
	free(f->tete); /* liberation du tableau contenant la file */
	free(f);       /* liberation de la tete de la file */
}

Conclusion :


La source "Bibliothèque de gestion de files dynamiques" permet d'utiliser des files auto-allouables, et non plus des files de taille fixe.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_Sunglasses)