Header pour gerer une pile dynamiquement

Télécharger le projet
Commenter

Description

Ce header contient les fonctions fondamentale pour gérer une pile de type LIFO.

Fontions présentes :
- Créer une pile (dCreateStack).
- poser un élément au dessus de la pile (dPush).
- Retirer un élément de la pile (dPop). Attention elle renvoie aussi la valeur de l'élément.
- Voir l'élément au dessus de la pile (dTop).
- Vérifer si la pile est vide ou non (dIsEmpty).
- Destruction de la pile (dDestroyStack).

Les constante T et EMPTY doivent être définies pour un bon fonctionnement.
T = type de l'élément.
EMPTY = Valeur retournée en cas de pile vide.

Compatible Linux & windows

Commande pour compiler le code avec gcc sous linux :
gcc cPile.h -o nom_souhaite -std=c99

Source / Exemple : 


/*


     
  •  Create by : deck_bsd

    •  
  •  Date of creation : 27/05/2006.

    •  
  •  Task : This header contain the fundamental functions for the to use a stack. (Linux/windows).

 *


     
  •  Remark : The constante T and EMPTY must be defined in a #define before the include of header.

    •  
  • /

 
 #include <stdbool.h>
 
 typedef struct element{
	 T tElem;
	 struct element * ptNext;
}ELEMENT;
 
 typedef struct stack{
	 ELEMENT * ptTop;
 }STACK;
 
 /*TASK : Create a stack. */
 STACK * dCreateStack(void){
	 STACK * ptPile;
	 
	 ptPile = (STACK*)malloc(sizeof(STACK));
	 if(ptPile == NULL) return NULL;
	
	ptPile->ptTop = NULL;
	
	return ptPile;
 }

/*TASK : Put a element onto the stack. */ 
bool dPush(STACK * ptPile,T ttElem){
	ELEMENT * ptNewElem;
	
	ptNewElem = (ELEMENT*)malloc(sizeof(ELEMENT));
	if(ptNewElem == NULL) return false;
	
	ptNewElem->tElem = ttElem;
	
	ptNewElem->ptNext = ptPile->ptTop;
	ptPile->ptTop = ptNewElem;
	
	return true;
}

/*TASK : Delete the element on the top of stack and return its value. */
T dPop(STACK * ptPile){
	T ttElem;
	ELEMENT *ptDes;
	
	if(ptPile->ptTop == NULL)return EMPTY;
	ptDes = ptPile->ptTop;
	ttElem = ptDes->tElem;
	
	ptPile->ptTop = ptDes->ptNext;
	
	free(ptDes);
	
	return ttElem;
}

/*TASK : return the value of the top. */
T dTop(STACK * ptPile){
	if(ptPile->ptTop != NULL)return ptPile->ptTop->tElem;
	return EMPTY;
}

/*TASK : check the state of the stack. */
bool dIsEmpty(STACK * ptPile){
	if(ptPile->ptTop == NULL)return true;
	return false;
}

/*TASK : destroy the stack. */
void dDestroyStack(STACK * ptPile){
	ELEMENT * ptDes,* ptSave;
	
	if(ptPile->ptTop != NULL){
		ptDes = ptPile->ptTop;
		while(ptDes != NULL){
			ptSave = ptDes->ptNext;
			free(ptDes);
			ptDes = ptSave;
		}
	}
	free(ptPile);
}
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 (deck_bsd)