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.