// Método que retorna o item do topo da pilha
T topo() {
if (PilhaVazia()) {
throw "Pilha Vazia";
} else {
return head->getInfo();
}
}
/* Desempilha um elemento, enviando uma mensagem de erro caso a pilha esteja
* vazia.
*/
ElemPilha* VerificaDesempilha(Pilha* pilha) {
if (PilhaVazia(pilha)) {
IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO);
}
return (ElemPilha*) Desempilha(pilha);
}
T desempilha() {
if (PilhaVazia()) {
throw std::runtime_error("Erro pilha vazia");
} else {
return ListaEnc<T>::retiraDoInicio();
}
}
T topo() {
if (PilhaVazia()) {
throw std::runtime_error("Erro pilha vazia.");
} else {
return ListaEnc<T>::getHead()->getInfo();
}
}
/** Função desempilha
* Se a pilha não estiver vazia, então diminui o número do topo.
* Não há o processo de apagar o dado desempilhado da pilha.
* Verifica o status da pilha através da função PilhaVazia.
* Se houver problema na verificação, redireciona a execução para
* lugar nenhum.
* Não possui parâmetro.
* Retorna o tipo genérico que representa o dado retirado da pilha.
*/
T desempilha() {
if (PilhaVazia()) {
throw "problema";
} else {
numeroTopo -= 1;
return dados[numeroTopo + 1];
}
}
ElemPilha* VerificaDesempilha(Pilha* pilha) {
/* Desempilha um elemento, enviando uma mensagem de erro caso a pilha */
/* esteja vazia. */
if (PilhaVazia(pilha)) {
IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO);
return NULL;
}
return (ElemPilha*) Desempilha(pilha);
}
// Método para desempilhar um dado
T desempilha() {
if (PilhaVazia())
throw "Pilha Vazia";
Elemento<T> *temp = head;
T aux = temp->getInfo();
head = head->getProximo();
temp->~Elemento();
--size;
return aux;
}
int main(){
Pilha s;
char aux;
//char inf[] = "(a-b)/(c+d)*e";
char inf[] = "A^B*C-D+E/F/(G-H)";
int i = 0;
inicPilha(&s);
for(i = 0; i < strlen(inf); i++) {
//printf("%c", inf[i]);
switch(inf[i]) {
case '(': push(&s, inf[i]); break;
case '*':
case '+':
case '/':
case '-':
case '^':
while(!PilhaVazia(&s) && verificaPrec(elemTopo(&s), inf[i]) &&
elemTopo(&s) != '(')
printf("%c", pop(&s));
push(&s, inf[i]);
break;
case ')':
aux = pop(&s);
while(aux != '('){
printf("%c", aux);
aux = pop(&s);
}
break;
default: printf("%c", inf[i]);
break;
}
}
while(!PilhaVazia(&s))
printf("%c", pop(&s));
printf("\n");
return 0;
}
/*!
\return as informações do elemento retirado da pilha
\sa empilha(), topo()
*/
void desempilha() {
Elemento<T> *aux;
if (PilhaVazia()) {
throw "pilha vazia";
} else {
aux = top;
size--;
top = aux-> getProximo();
delete aux;
}
}
void inverte_string(char * str){
int i=0;
do{
push(s,str[i]);
}while(str[i++]!='\0');
do{
printf("%c",pop(s));
}while(!PilhaVazia());
}
/* Retorna o polinômio referente à expressão dada; este polinômio devolvido é
* sempre uma nova cópia, mesmo que a expressão seja uma variável simples.
*/
Polinomio CalcExpr(char* expr) {
Pilha polPilha;
ElemPilha *r;
Polinomio p;
int i;
CriaPilha(&polPilha);
i = 0;
while (expr[i] != '\0') {
if (Operando(expr + i)) {
EmpilhaOperando(&polPilha, RecuperaPolinomio(expr[i]), false);
} else if (Operador(expr + i)) {
ExecutaOperacao(&polPilha, expr[i]);
} else {
IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO);
}
i++;
}
r = VerificaDesempilha(&polPilha);
if (!PilhaVazia(&polPilha)) {
IMPRIME_ERRO(MSG_ERRO_FALTA_OPERADOR);
}
if (r->temp) {
p = r->poli;
} else {
p = CopiaPolinomio(r->poli);
}
FREE(r);
return p;
}
/** Função getter para a posição do topo
* Se a pilha não estiver vazia, retorna a posição do elemento no topo
* da pilha.
* Verifica o status da pilha através da função PilhaVazia.
* Se houver problema na verificação, redireciona a execução para
* lugar nenhum.
* Não possui parâmetro.
*/
int getPosTopo() {
if (PilhaVazia())
throw "problema";
else
return numeroTopo;
}
/*!
\sa PilhaEnc(), ~PilhaEnc(), PilhaVazia()
*/
void limparPilha() {
while (!PilhaVazia()) {
desempilha();
}
}
/*!
\return informações do elemento no topo da pilha
\sa empilha(), desempilha()
*/
T topo() {
if (PilhaVazia()) {
throw "Pilha Vazia";
}
return top->getInfo();
}
void* Desempilha (Pilha* p) {
/* Desempilha um elemento da pilha. */
if (PilhaVazia(p))
IMPRIME_ERRO(MSG_ERRO_PILHA_VAZIA);
return p->vetor[p->topo--];
}
Polinomio CalcExpr(char* expr) {
/* Retorna o polinômio referente à expressão dada. */
/* O polinômio devolvido é sempre uma nova cópia, mesmo que a */
/* expressão seja uma variável simples. */
Pilha operacao;
ElemPilha *aux1, *aux2;
Polinomio temp;
CriaPilha(&operacao);
printf("Comeca a CalcExpr\n");
/*Faz a leitura da expressão dada, termo por termo, até chegar no final da linha*/
while(*expr != '\0'){
/*Caso a entrada seja um operador*/
if(!Operando(*expr)){
printf("Operando\n");
/*Caso o operador seja binário*/
if(*expr == '+' || *expr == '-' || *expr == '*'){
/*Como é um operador, deve-se utilizar os dois elementos do topo da pilha*/
aux1 = VerificaDesempilha(&operacao);
aux2 = VerificaDesempilha(&operacao);
/*Caso tente desempilhar mas a pilha ja esta vazia, entao falta operandos*/
if(aux1 == NULL || aux2 == NULL){
IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO);
}
/*Faz a operacao entre os dois elementos desempilhados*/
if(*expr == '+'){
printf("Soma\n");
temp = SomaPolinomios(aux2->poli, aux1->poli);
}
else if(*expr == '-'){
printf("Sub\n");
temp = SubPolinomios(aux2->poli, aux1->poli);
}
else if(*expr == '*'){
printf("Multi\n");
temp = MultPolinomios(aux2->poli, aux1->poli);
}
/*Empilha o elemento resultante das operacoes*/
EmpilhaOperando(&operacao, temp, true);
/*Libera os elementos da pilha utilizados*/
if(aux1->temp == true){
LiberaPolinomio(aux1->poli);
}
if(aux2->temp == true){
LiberaPolinomio(aux2->poli);
}
FREE(aux1);
FREE(aux2);
}
/*Caso o operador seja unário*/
else if(*expr == '~'){
/*Como é um operador unario, só é nescessario usar o elemento do topo
da pilha*/
aux1 = VerificaDesempilha(&operacao);
temp = MultTermo(aux1->poli, 0, -1.0);
EmpilhaOperando(&operacao, temp, true);
/*Desaloca a memoria nescessaria*/
if(aux1->temp == true){
LiberaPolinomio(aux1->poli);
}
FREE(aux1);
}
/*Se não entrou em nenhum dos outros casos, a entada é invalida*/
else{
IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO);
}
}
/*Se a entrada não for um operador, é um polinomio*/
else{
printf("Operador\n");
/*Empilha o elemento apontado na pilha operacao*/
EmpilhaOperando(&operacao, vetorPoli[*expr - 'A'], false);
}
/*Avança a leitura*/
expr++;
}
/*Depois de terminar de ler as operacoes retira o ultimo elemento e verifica se
a pilha está vazia, se sim, é por que completou as operacoes corretamente, entao
retorna esse polinomio
*/
aux1 = VerificaDesempilha(&operacao);
if(PilhaVazia(&operacao)){
temp = aux1->poli;
/*Cria um novo polinomio para poder ser retornado caso o elemento retornado seja
uma das 5 bases*/
if(aux1->temp == false){
temp = MultTermo(aux1->poli, 0, 1.0);
}
/*Desaloca o ultima elemento da pilha*/
FREE(aux1);
return temp;
}else{
/*Se a pilha ainda conter algum elemento*/
IMPRIME_ERRO(MSG_ERRO_FALTA_OPERADOR);
}
}
/** Função topo
* Se a pilha não estiver vazia, retorna o tipo genérico que
* representa o dado no topo da pilha.
* Verifica o status da pilha através da função PilhaVazia.
* Se houver problema na verificação, redireciona a execução para
* lugar nenhum.
* Não possui parâmetro.
*/
T topo() {
if (PilhaVazia())
throw "problema";
else
return dados[numeroTopo];
}