Calculadora - Notaçao polonesa

Bem-vindo!

Sugiro que use uma pilha para armazenar os símbolos lidos.

Assim, cada símbolo lido é empilhado, até que o símbolo lido seja um operador. Então, você desempilha quantos operandos forem necessários para aplicação do operador e empilha o resultado da operação.

Exemplo em pseudocódigo:

3 5 + 12 *

--

1. push(3)
2. push(5)
3. push(pop() + pop())
4. push(12)
5. push(pop() * pop())

Cuidado ao traduzir o pensamento acima para C. Em C, a ordem dos argumentos em uma chamada de função é não-especificada. Isto quer dizer que bin_op('+', pop(stack), pop(stack)), que seria uma forma atraente de expressar a aplicação de um operador, resultaria em erros para operações não-comutativas, e em que a implementação define ordem inversa de computação dos argumentos (pop() e pop()).

Pode perguntar se tiver mais dúvidas.

Uma implementação da pilha LIFO, descrita por Guidjos.

/*
* Copyright 2012 Mateus G. Pereira
*
* Este programa é um software livre; você pode redistribui-lo e/ou
* modifica-lo dentro dos termos da Licença Pública Geral GNU como
* publicada pela Fundação do Software Livre (FSF); na versão 2 da
* Licença, ou (na sua opnião) qualquer versão.
*
* Este programa é distribuido na esperança que possa ser util,
* mas SEM NENHUMA GARANTIA; sem uma garantia implicita de ADEQUAÇÂO
* a qualquer MERCADO ou APLICAÇÃO EM PARTICULAR. Veja a Licença
* Pública Geral GNU para maiores detalhes.
*
* Você deve ter recebido uma cópia da Licença Pública Geral GNU
* junto com este programa, se não, escreva para a Fundação do Software
* Livre(FSF) Inc., 51 Franklin St, Fifth Floor, Boston,
* MA 02110-1301 USA
*
*/

#include <stdio.h>
#include <stdlib.h>

// Imprementação de uma pilha, LIFO.

typedef struct stack
{

 void* element;
 struct stack* last;
} stack;

// Pilha de endereços

int push (stack** st, void* elm)
{

 stack* nstac;

 nstac = (stack*) malloc( sizeof(stack) );

 if(nstac == NULL)
 return 0;

 nstac->element = elm;
 nstac->last = *st;
 *st = nstac;
 return 1;
}

void* pop (stack** st)
{

 stack* aux;
 void* elm;

 if(*st == NULL)
 return NULL;

 elm = (*st)->element;
 aux = (*st)->last;

 free(*st);
 *st = aux;

 return elm;
}

void top (stack st)
{

 if(st == NULL)
 return NULL;

 return st->element;
}

int emp (stack* st)
{

 return st == NULL;
}

// Pilha de numeros inteiros

int ipush (stack** st, int elm)
{

 int* ilm;

 ilm = (int*) malloc( sizeof(int) );

 if(ilm == NULL)
 return 0;

 *ilm = elm;

 return push(st, ilm);
}

int ipop (stack** st)
{

 void* elm;

 elm = pop(st);

 if(elm == NULL)
 return 0;
 return *(int*)elm;
}

int itop (stack* st)
{

 void* elm;

 elm = top(st);

 if(elm == NULL)
 return 0;
 return *(int*)elm;
}

int main (int argc, char* argv[])
{

 stack* st = NULL;
 int i = 10;

 printf("Calculos usando pilha\n");
 while(i > 1)
 if(!ipush(&st, i--))
 break;

 i = ipop(&st);
 while(!emp(st))
 i *= ipop(&st);

 printf("10! = %d\n", i);

 i = 800;
 while(i > 0)
 if(!ipush(&st, i--))
 break;

 i = ipop(&st);
 while(!emp(st))
 i += ipop(&st);

 printf("1+2+3+4+...+800 = %d\n", i);

 i = 100;
 while(i > 0)
 {
 if(!ipush(&st, (i * i)))
 break;
 i--;
 }

 i = ipop(&st);
 while(!emp(st))
 i += ipop(&st);

 printf("1²+2²+3²+4²+...+100² = %d\n", i);
 return 0;
}

Obs.: Para um proposito especifico, como no seu caso, recomendo alterar o tipo da variável element, para um mais conveniente.