BIBLIOTHÈQUE DE GESTION DES PILES STATIQUES EN C

pile.h :

#ifndef _pile_h_
#define _pile_h_

#include <stdlib.h>

typedef int variant; /* remplacer int par le type de donnees a empiler */

/*---------------- STRUCTURE DE PILE.C ---------------------------------------------*/

/*
  Structure :
  Nom	:	pile
  Fct	:	structure definissant une pile d'elements de type "variant"
*/

typedef struct pile
{
  int n;           /* nombre d'elements presents dans la pile moins un */
  int max;         /* nombre maximum d'elements de la pile */
  variant * tete;  /* pointeur de tete de la pile */
} pile_t;


/*---------------- FONCTIONS DE PILE.C ---------------------------------------------*/

/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la pile est vide
  Entree	:	(p) adresse de la pile
  Sortie	:	booleen indiquant que la pile est vide
*/

unsigned short int vide(pile_t * p);

/*
  Nom	:	pleine
  Fct	:	retourne un booleen indiquant si la pile est pleine
  Entree	:	(p) adresse de la pile
  Sortie	:	booleen indiquant que la pile est pleine
*/

unsigned short int  pleine(pile_t * p);

/*
  Nom	:	init
  Fct	:	cree une nouvelle pile et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la pile
  Sortie	:	adresse de la nouvelle pile
*/

pile_t * init(int maxi);

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

unsigned short int empile(pile_t * p, variant x);

/*
  Nom	:	depile
  Fct	:	depile un element de la pile et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(p) adresse de la pile
			(x) adresse de stockage de l'element depile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

unsigned short int depile(pile_t * p, variant * x);

/*
Nom	:	supprime
Fct	:	libère toute la mémoire occupée par une pile
Entree	:	(p) adresse de la pile
*/

void supprime(pile_t * p);

#endif



pile.c :

#include "pile.h"

/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la pile est vide
  Entree	:	(p) adresse de la pile
  Sortie	:	booleen indiquant que la pile est vide
*/

unsigned short int vide(pile_t * p)
{
  return ((p->n) == -1); /* la pile est vide si n=-1 */
}

/*
  Nom	:	pleine
  Fct	:	retourne un booleen indiquant si la pile est pleine
  Entree	:	(p) adresse de la pile
  Sortie	:	booleen indiquant que la pile est pleine
*/

unsigned short int  pleine(pile_t * p)
{
  return ((p->n)+1 == (p->max)); /* la pile est pleine si n+1=max */
}

/*
  Nom	:	init
  Fct	:	cree une nouvelle pile et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la pile
  Sortie	:	adresse de la nouvelle pile
*/

pile_t * init(int maxi)
{
  pile_t * adr_pile=NULL; /* l'adresse de la pile est NULL si l'allocation echoue */
  
  adr_pile = (pile_t *)malloc(sizeof(pile_t)); /* adresse de la pile cree */
  if ( adr_pile )
  {
    adr_pile->n = -1;                            /* nombre d'elements presents (aucun) */
    adr_pile->max = maxi;                        /* nombre maximal d'elements */
    adr_pile->tete = (variant *)malloc(maxi * sizeof(variant)); /* allocation du tableau contenant les elements empiles */
  }
  
  return adr_pile;
}

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

unsigned short int empile(pile_t * p, variant x)
{
  unsigned short int succes = 0;
  
  if (p->max != p->n + 1) /* si la pile n'est pas pleine */
    {
      p->n = p->n + 1;       /* incrementation du nombre d'elements */
      *(p->tete + p->n) = x; /* rajout du nouvel element sur la pile */
      succes = 1;            /* marquage de la reussite */
    }
  
  return succes;
}

/*
  Nom	:	depile
  Fct	:	depile un element de la pile et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(p) adresse de la pile
			(x) adresse de stockage de l'element depile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

unsigned short int depile(pile_t * p, variant * x)
{
  unsigned short int succes = 0;
  
  if ( !vide(p) )
    {
      *x = *(p->tete + p->n); /* sortie du dernier element rajoute */
      p->n = p->n - 1;        /* decrementation du nombre d'elements */
      succes = 1;             /* marquage de la reussite */
    }
  
  return succes;
}

/*
Nom	:	supprime
Fct	:	libère toute la mémoire occupée par une pile
Entree	:	(p) adresse de la pile
*/

void supprime(pile_t * p)
{
	free(p->tete); /* liberation du tableau contenant la pile */
	free(p);       /* liberation de la tete de la pile */
}