AccueilCodesTutorielsForumsEmploiLivresGuide achatConnexion

  • C / C++ / C++.NET CodeS-SourceS
  • RSS CodeS-SourceS
  • CodyxBot, le Bot GTalk & MSN qu'il vous faut !
  • Générez des revenus avec vos codes, scripts et tutoriaux
  • Aide à la navigation du site
begin process at 2009 07 06 11:11:01
Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

BIBLIOTHÈQUE DE GESTION DES PILES STATIQUES EN C


Information sur la source

Catégorie :Divers Classé sous : piles, pile, stack, lifo, langage c Niveau : Débutant Date de création : 15/04/2007 Date de mise à jour : 07/10/2007 00:21:24 Vu / téléchargé: 4 309 / 216
Auteur : Sunglasses Site perso
Ecrire un message privé
Ce membre participe au partage de revenus publicitaires
Note :
Aucune note
Commentaire sur cette source (0)
Ajouter un commentaire et/ou une note

Description

(Plus de précisions sur mon site : http://perso.orange.fr/beorn/progra_c/pile_statique.html )

Les fichiers pile.c et pile.h forment une bibliotheque permettant de gérer des piles statiques.

Le type utilisé pour les piles est "pile_t".
La pile est dite statique car elle stocke ses éléments dans un tableau dont la taille est définie. La pile possède donc un nombre déléments maximal.

Les différentes fonctions sont :
- vide : vaut 1 si la pile est vide, 0 sinon
- pleine : vaut 1 si la pile est pleine, 0 sinon
- init : alloue une pile en mémoire (le paramètre de cette fonction est la taille maximale de la pile) et renvoie son adresse
- empile : permet d'empiler un nouvel élément sur la pile (renvoie 1 si la pile est pleine, 0 sinon)
- depile : dépile le dernier élément rajouté (renvoie 1 si la pile est vide, 0 sinon)
- supprime : libère tout l'espace mémoire utilisé par une pile

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

  • 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 */
  • } 
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 */
}

Conclusion

Ceci est probablement ma version finale.
Il est vrai qu'il s'agit d'une source tout ce qu'il y a de plus classique en ce qui concerne la gestion d'une pile en C.
Mais je l'ai mise, car je n'ai pas trouvé d'équivalents en C dans CPPFrance.com.

J'ai mis également une source permettant de travailler avec des piles qui ne sont pas limitées en taille :
BIBLIOTHÈQUE DE GESTION DES PILES DYNAMIQUES EN C
 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !
  •   pile statique

Télécharger le zip

Historique

15 avril 2007 20:59:45 :
Titre de la source complété
15 avril 2007 21:10:54 :
Modification des mots clés
16 avril 2007 20:38:38 :
Modification mots clés
16 avril 2007 20:39:23 :
Modification mots clés
16 avril 2007 21:00:11 :
Modification du titre
07 mai 2007 20:48:33 :
Fignolage du code, et de la description
08 mai 2007 14:48:59 :
Modifications mineures
07 août 2007 21:57:28 :
Rajout de la fonction "pleine"
07 août 2007 21:59:39 :
Orthographe
10 août 2007 12:11:38 :
modifications mineures
13 août 2007 00:03:25 :
modification mineure
07 octobre 2007 00:21:24 :
+ lien

Commentaires et avis

Aucun commentaire pour le moment.

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

Utilisation de stack en C++ [ par jagdjg ] J essaie de faire un stack mais ca ne marche pas La declaration est : Stack* pile = new Stack();le push : pile-&gt;Push(strPile);le pop : strPile = pi [C] Généricité et cast automatique. [ par LocalStone ] Salut, Alors voilà ... Je me posais la question suivante : existe-t-il un moyen en C de gérer la généricité de manière transparente ? Je m'explique .. stack et char * [ par yuriashford ] Salut &#224; tous je developpe actuellement une application qui utilise une stack de STL&nbsp; la stack est une declar&#233; : stack&lt;char *&gt; pil Pile de double [ par Pof ] Bonjour ! voil&#224; j'ai un petit probl&#232;me avec les std::stack :std::stack&lt;double&gt; stack;stack.push(20);stack.push(10);[...]double a = sta aide pour calcul de formule [ par snakers07 ] bonjour, j'ai crée un programme permettant de calculer une formule utilisant les opérateurs +,-,*,/ avec un controle sur les parenthése:par exemple :( Intersection de deux FIFO !!! [ par codecpp ] Bonjour à tous, Je cherche un algo optimal :) ou un code c :)) pour faire l'intersection de deux piles FIFO. Je cherche à trouver l'ensemble des poi Pb avec les piles et les files [ par manta7 ] Salut &#224; tous, j'ai essay&#233; de cr&#233;er un programme qui permet de g&#233;rer les piles et les files mais le programme suivant a tout le tem TCP/IP Stack [ par anahouana ] Bonjour, j'ai un projet dans lequel je dois comprendre le code sourc dTCP/IP et la nation de  la pile de TCP/IP ...donc si vous avez déja le code sour Infos sur la pile et le tas [ par clempar55 ] Voila je vois souvent sur le forum des phrases telles que "tel objet a été créé sur la pile/le tas", "tel paramètre a été dépilé". J'ai enfin décidé d


Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Téléchargements

Logiciels à télécharger sur le même thème :

Comparez les prix Nouvelle version


Adobe Flex Builder
Entre 607€ et 607€


Visiter le guide achat

Photothèque Nouveau !

Photo friends at the beach.Photo friends
Photo regard intense d'une magnifique femmePhoto accident de la route

Visiter la photothèque


Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,187 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.