PILHA.H PILHA.C

PILHA.H
/* no turboC para DOS use:
#include "client~1.h"*/
#include "clientePilha.h"
/*
operacao de manipulacao:
pre-condicao: existencia do TDA cujo endereco eh passado, juntamente com uma
referencia para uma variavel do tipo info.
pos-condição: se possível remove o item do topo da pilha, o copia para o local
de memória apontado por pReg e retorna SUCESSO, caso contrário retorna FRACASSO
*/
int desempilha(pPilha p, info *pReg);
/*#define M 10*/
#define LIVRE 0
#define OCUPADA 1
#define FRACASSO 0
#define SUCESSO 1
#define TRUE 1
#define FALSE 0
#define VERDADEIRO 1
#define VAZIA -1
/*
tipo de operação: função destrutora.
pre condicao: a existência do tda e um apontador declarado externamente à função,
devidamente inicializado com o endereço do tda e cujo endereço (deste apontador) é
passado para funcao.
pos condicao: destrói o TDA desalocando qualquer região de memória previamente
alocada
para o mesmo e fazendo o ponteiro que o referenciava receber NULL.
*/
void destroi(ppPilha pp);
/* Header (descritor) – modelo de dados do TDA*/
typedef struct {
info *vet; /* ponteiro para o vetor */
int topo; /* topo da pilha */
int tamanho; /*tamanho físico do vetor/tamanho máximo da pilha */
}Pilha, *pPilha, **ppPilha;
/*operação de criacao:
pre-condica: existencia de um apontador do tipo do tda passado por referencia
para a funcao juntamente com o tamanho (>0) do tda a ser criado
pos-condicao: criacao e inicializacao do TDA, atribuicao do seu endereco ao
ponteiro passado por referencia. Em caso de problemas na criacao será sinalizado
(retornado)o seu FRACASSO, caso contrário será sinalizado o seu SUCESSO.
*/
int cria(ppPilha pp, int tamanho);
/*
operacao de acesso:
pre-condicao: existencia do TDA cujo endereco eh passado, juntamente com uma
referencia para uma variavel do tipo info.
pos-condição: em caso de sucesso copia o item no topo para o local de memória
apontado por pReg e retorna SUCESSO, caso contrário retorna FRACASSO
*/
int buscaNoTopo(pPilha p, info *pReg);
/*
operacao de manipulacao:
pre-condicao: existencia do TDA cujo endereco eh passado, juntamente com uma
referencia para o novo registro de informaçao a ser empilhado.
pos-condição: em caso de sucesso retorna SUCESSO, caso contrário retorna FRACASSO
*/
int empilha(pPilha p, info *novo);
/*
tipo de operação: função de manipulação.
pre condicao: a existência do tda cujo endereço é passado para a função
pos condicao: "esvazia" o tda de dados. O TDA volta às mesmas condições que existiam
imediatamente após a sua criação
*/
void purga(pPilha p);
/*
tipo de operação: função de acesso.
pre condicao: a existência do tda cujo endereço é passado para a função
pos condicao: se o TODA estiver vazio, retorna TRUE, caso contrário retorna FALSE.
imediatamente após a sua criação
*/
int testaVazia(pPilha p);
/*
tipo de operação: função de acesso.
pre condicao: a existência do tda cujo endereço é passado para a função
pos condicao: se o TODA estiver cheio, retorna TRUE, caso contrário retorna FALSE.
imediatamente após a sua criação
*/
int testaCheia(pPilha p);
PILHA.C
/*#include "tda_ve~1.h"*/
#include "tda_pilha.h"
int cria(ppPilha pp, int tamanho)
{ int ret = FRACASSO;
if ( ( *pp = (pPilha) malloc(sizeof(Pilha)) )!=NULL ) /* cria header */
{ (*pp)->vet = (info *) malloc(tamanho*sizeof(info)); /* cria vetor */
if ( (*pp)->vet !=NULL )
{ (*pp)->tamanho = tamanho; /*inicia tamanho do vetor*/
(*pp)->topo = VAZIA; /*inicia pilha vazia */
ret = SUCESSO;
}
else
{ free(*pp);
*pp = NULL;
}
}
return ret;
}
int buscaNoTopo(pPilha p, info *pReg)
{ int ret;
if (p->topo == VAZIA) /* acesso direto ao topo */
ret = FRACASSO;
else
{ *pReg = p->vet[p->topo]; /* OU *pReg = *(p->vet + p->topo); */
ret = SUCESSO;
}
return ret;
}
int empilha(pPilha p, info *novo)
{ if (p->topo >= p->tamanho-1)
return FRACASSO;
else
{ p->topo++;
*(p->vet + p->topo) = *novo; /* OU p->vet[p->topo] = *novo;
return SUCESSO;
}
}
*/
int desempilha(pPilha p, info *pReg)
{ if (p->topo == VAZIA)
return FRACASSO;
else
{ *pReg = *(p->vet + p->topo); /* OU *pReg = (p->vet[p->topo]); */
p->topo--;
return SUCESSO;
}
}
void destroi(ppPilha pp)
{ free((*pp)->vet);
free(*pp);
*pp = NULL;
}
void purga(pPilha p)
{ p->topo = VAZIA;
}
int testaVazia(pPilha p)
{ int ret;
if (p->topo == VAZIA) /* acesso direto ao topo */
ret = TRUE;
else
ret = FALSE;
return ret;
}
int testaCheia(pPilha p)
{ int ret;
if (p->topo >= p->tamanho-1) /* acesso direto ao topo */
ret = TRUE;
else
ret = FALSE;
return ret;
}
CLIENTE.H
/*modelo de dados da aplicação - cliente do TDA*/
typedef struct { char matricula[N];
}info;
CLIENTE.C
/*#include "tda_ve~1.h"*/
#include "tda_pilha.h"
main()
{ pPilha p = NULL;/*MANTENHA ’P’ COMO REFERNCIA PARA O TDA */
int tam;
char opc;
puts ("entre com tamanho do tda");
scanf("%i",&tam);
if (cria(&p, tam)==SUCESSO);
{info auxInfo;
do{ clrscr();
puts(" entre com uma opcao");
puts(" 1-busca no topo, 2-empilha, 3-desempilha");
puts(" 4-estah vazia ?, 5-estah cheia ?");
puts(" 0-para encerrar");
printf("\n");
fflush(stdin);
opc = getche();
switch (opc)
{ case ’1’:
if( buscaNoTopo(p,&auxInfo)==FRACASSO)
puts("pilha vazia!");
else
printf("\n informacao no topo: %s \n",auxInfo.matricula);
break;
case ’2’:
if(testaCheia(p))
puts("erro na insercao: estrutura de dados cheia !");
else
{ printf("\nentre com a matricula:\n");
gets(auxInfo.matricula);
empilha(p,&auxInfo);
puts("SUCESSO na insercao");
}
break;
case ’3’:
if(desempilha(p,&auxInfo)== FRACASSO)
puts("Erro no desempilha pois o tda esta vazio!");
else
printf("\n retirou o : %s \n", auxInfo.matricula);
break;
case ’4’:
.....................
case ’0’:
destroi(p);
break;
}
getche();
}while(opc != ’0’);
}
return;
}