begin process at 2010 03 15 06:45:03
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Divers

 > BIBLIOTHÈQUE DE GESTION DES PILES STATIQUES EN C

BIBLIOTHÈQUE DE GESTION DES PILES STATIQUES EN C


 Information sur la source

Note :
Aucune note
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é :5 016 / 286

Auteur : Sunglasses

Ecrire un message privé
Site perso
Ce membre participe au partage de revenus publicitaires
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_statiqu e.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

Les Membres Club peuvent 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

 Sources du même auteur

Source avec Zip Source avec une capture VISUALISEUR RVB AVEC QT
Source avec Zip TEMPLATE DE VECTEUR AVEC TIRAGE ALEATOIRE (C++)
Source avec Zip BIBLIOTHÈQUE DE GESTION DE FILES DYNAMIQUES
Source avec Zip BIBLIOTHÈQUE DE GESTION DE FILES STATIQUES
Source avec Zip BIBLIOTHÈQUE DE GESTION DE MATRICES EN C

 Sources de la même categorie

Source avec une capture POWER MATH: TESTE DE VITESSE ENTIERS VS REELS , CLASS VS STR... par dedalusman
Source avec Zip PARSER XML par MagnumPP
[C BZLIB] LIRE ET ÉCRIRE UN FICHIER COMPRESSÉ par Zestyr
Source avec Zip Source avec une capture BOT DE CLIC (SIMULATION DE CLIC PARAMÈTRABLE) par jojo930
Source avec Zip Source avec une capture [C++] GENERATEUR DE PSEUDO par Miwik

 Sources en rapport avec celle ci

Source avec une capture STACK WATCHER par lilxam7
Source avec Zip BIBLIOTHÈQUE DE GESTION DES PILES DYNAMIQUES EN C par Sunglasses
Source avec Zip Source avec une capture RÉSOLUTION DE LABYRINTHE AVEC PILE par damned3
GESTION D'UNE PILE PAR LES CLASSES par UKR6900
Source avec Zip VSTACK ( EFFET DE PILE ) / TEMPLATE par NitRic

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 :( trier d'une liste chainee en utilisant 2 piles [ par bella086 ] bsr voila j'ai un petit bon disant grand pblm sur c++ je dois charger une pile p1 a partir dune liste chainee et puis trier la pile p1 a laide d'une Erreur : la variable a besoin du frame de pile [ par clavat ] Bonjour a tous ! je fait mon programme tout fonctionne il compile il fonctionne...je le modifie quelque peut et la il compile toujours mais ne fonctio 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 les histoire de piles et de file..... [ par handetaker ] J'amerais avoir un site ou je peux avoirs des exercices avec leur corrections sur des piles et des files,si possible les arbres pour un Debutant.merci Perte de messages [ par mohdaef ] Bonjour à tous Je suis entrain de programmer un petit multijoueur, et pour cela je doit échanger des messages entre les différents programmes. Pour


Nos sponsors


Appels d'offres

Sondage...

CalendriCode

Mars 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

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

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,749 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales