Calculadora - Notaçao polonesa

[potatopie 0]

Sou novo na programação, portanto tenham paciência comigo. Tenho que fazer um algoritmo que receba um arquivo de entrada e calcule os números em suas linhas, que estão juntos com os operadores na notação polonesa reversa, e que depois coloque o resultado em um arquivo de saída.Cada quebra de linha ou espaço no arquivo delimita o escopo dos cálculos que tenho que realizar com os elementos dessa linha. Criei um procedimento que passa os caracteres do arquivo para uma matriz de char. Depois disso, não sei bem o que faço. Pensei em usar strtok, nao sei...

 

Pensei alguma coisa assim, em pseudolinguagem:

 

for(i=0; i<strlen(vetor); i++){ //para percorrer o vetor procurando por operadores

 

 

if((vetor=='+')&&(i>=2)) //tenho tb que colocar uma condiçao pra vetor[i-2] e vetor[i-1] serem números..

 

x=vetor[i-2]+vetor[i-1];

vet[i-2]=x;

 

for(j=i; j<strlen(vetor)-1; j++){ //isso seria para "puxar" elementos do vetor pra posições antecessoras as suas.

 

if(j<=strlen(vetor)-2)

vetor[j-1]=vetor[j+1];

 

if(j==strlen(vetor)-1)

vetor[j-1]=' ';

 

}

 

i-- //para começar na posição 0

 

break;

 

e assim vai...mas nao sei se assim vai resolver meu problema..

Por favor, me ajudem..E tenham paciência, sou novo na programação...

[guidjos 65]

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.

[Mateus GP 13]

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.