Modificação do avaliador de notação pós-fixada. Modifique o programa avaliador de pós-fixo do Exercício 12.13 para que possa processar operandos inteiros maiores que 9.
Passo 1
Vamos modificar o programa avaliador postfix do exercício anterior para que ele possa operar com números de mais de um dígito.
Para fazer isso, precisaremos modificar a funçãovaluPostfixExpression() para que ela leia as informações de maneira diferente.
Primeiro, vamos lembrar o núcleo do programa (veja também a definição de constante adicionada que usaremos como o limite de dígitos que um número pode ter):
#define MAX 10
struct stackNode
{
int data;
struct stackNode* nextPtr;
};
typedef struct stackNode StackNode;
typedef StackNode* StackNodePtr;
int evaluatePostfixExpression(char* expr);
int calculate(int op1, int op2, char operator);
void push(StackNodePtr* topPtr, int value);
int pop(StackNodePtr* topPtr);
int isEmpty(StackNodePtr topPtr);
void printStack(StackNodePtr topPtr);
int main(void)
{
char postfix[100] = "";
int i = 0;
printf("Enter the expression: ");
do
{
postfix[i] = getchar();
} while (postfix[i++] != '\n');
postfix[i - 1] = '\0';
printf("Result: %d",
evaluatePostfixExpression(postfix));
return 0;
}
Passo 2
Agora, vamos para a funçãovaluPostfixExpression().
Continuaremos a ler caractere por caractere, mas usaremos o fato de que todos os números/operadores são divididos por caracteres de espaço.
Se um dígito for encontrado, vamos salvá-lo em uma matriz de caracteres, que analisaremos posteriormente em um inteiro, e salvaremos um valor "booleano" que servirá como um indicador se a entidade anterior for um número.
Cada vez que um caractere de espaço é lido, verificamos o indicador para ver se lemos um número. Se isso for verdade, vamos empurrar o número e redefinir a matriz e o indicador.
Para começar, declare as variáveis necessárias e inicialize o array com caracteres nulos porque nos referiremos ao array como uma "string".
int evaluatePostfixExpression(char* expr)
{
StackNodePtr pStack = NULL;
int x, y;
// new code
int wasDigit = 0;
char* digit = (char*)malloc(MAX);
for (int i = 0; i
digit[i] = '\0';
int count = 0;
...
}
Em seguida, insira o loop:
int avaliaPostfixExpression(char* expr)
{
...
for (int i = 0; expr[i] != '\0'; i++)
{
...
}
...
}
Passo 3
Se o caractere lido for um dígito, salve-o na matriz de dígitos e atualize o indicador da seguinte forma:
int evaluatePostfixExpression(char* expr)
{
...
for (int i = 0; expr[i] != '\0'; i++)
{
if (isdigit(expr[i]))
{
digit[count++] = expr[i];
wasDigit = 1;
}
...
}
...
}
Caso contrário, se um caractere de espaço for lido e o caractere lido anterior for um dígito, empurre o número usando a função push(), passando a string analisada para um inteiro usando a função atoi().
Certifique-se de redefinir os contadores, matriz e indicador.
int evaluatePostfixExpression(char* expr)
{
...
for (int i = 0; expr[i] != '\0'; i++)
{
...
else if (expr[i] == ' ' && wasDigit)
{
push(&pStack, atoi(digit));
wasDigit = 0;
for (int j = 0; j
digit[j] = '\0';
count = 0;
}
...
}
...
}
Caso contrário, um operador é lido, então pop os números e empurre o valor calculado da seguinte forma:
int evaluatePostfixExpression(char* expr)
{
...
for (int i = 0; expr[i] != '\0'; i++)
{
...
else
{
x = pop(&pStack);
y = pop(&pStack);
push(&pStack, calculate(y, x, expr[i]));
}
}
...
}
Certifique-se de desalocar a memória usada pelo array dinâmico de dígitos e retornar o valor do último elemento da pilha:
int evaluatePostfixExpression(char* expr)
{
...
free(digit);
return pop(&pStack);
}
Resposta
Ver o desenvolvimento.