C语言中程序的错误答案（中缀符号->；后缀符号）

我制作了一个程序，使用C中的堆栈将中缀符号更改为后缀符号

我制作了一个函数来打印后缀符号的结果（来自中缀notaton）

但是，符号的结果是错误的。这应该是'195'，但其结果是'-61'

其他符号的结果是正确的，但只有符号（op2）有这个问题

我应该如何解决此问题

这是我的代码：

typedef char element;
 
typedef struct {
    element stack[MAX_STACK_SIZE];
    int top;
} StackType;
 

void init(StackType *s) {
    s->top = -1;
}

int is_empty(StackType *s) {
    return (s->top == -1);
}

int is_full(StackType *s) {
    return (s->top == (MAX_STACK_SIZE - 1));
}

 
void push(StackType *s, element item) {
    if (is_full(s)) {
        fprintf(stderr, "FULL STACK ERROR\n");
        return;
    }
    else s->stack[++(s->top)] = item;
}
 
element pop(StackType *s) {
    if (is_empty(s)) {
        fprintf(stderr, "EMPTY STACK ERROR\n");
        exit(1);
    }
    else return s->stack[(s->top)--];
}
 
 
int eval(char exp[]) {
    int op1, op2, value, i = 0;
    int len = strlen(exp);
    char ch;
    StackType s;
    init(&s);
    for (i = 0; i < len; i++) {
        ch = exp[i];
        if (ch != '+' && ch != '-' && ch != '*' && ch != '/') {
            value = ch - '0';        
            push(&s, value);
        }
        else {                          
            op2 = pop(&s);
            op1 = pop(&s);
            switch (ch) {            
            case '+': push(&s, op1 + op2); break;
            case '-': push(&s, op1 - op2); break;
            case '*': push(&s, op1 * op2); break;
            case '/': push(&s, op1 / op2); break;
            }
        }
    }
    return pop(&s);
}
 
char* infix_to_postfix(char exp[]) {
    int i = 0, j = 0;
    char ch, top_op;
    int len = strlen(exp);
    char *ex = (char *)malloc(sizeof(char)*(len + 1));
    StackType s;

    init(&s);
    for (i = 0; i < len; i++) {
        ch = exp[i];
        switch (ch) {
        case '+': case '-': case '*': case '/': 
            while (!is_empty(&s) && (prec(ch) <= prec(peek(&s)))) {
                ex[j++] = pop(&s);
            }
            push(&s, ch);
            break;
        case '(':       
            push(&s, ch);
            break;
        case ')':       
            top_op = pop(&s);
            while (top_op != '(') {
                ex[j++] = top_op;
                top_op = pop(&s);
            }
            break;
        default:
            ex[j++] = ch;
            break;
        }
    }
    while (!is_empty(&s)) {
        ex[j++] = pop(&s);
    }
    ex[j] = NULL;           
    return ex;
}

void main() {
    char *op1 = "(9-(3+2))*3+4*((4+2)/3)-1";
    char *op2 = "(4*5-3)/3+((2+5*7)-8+9)*5";          
    char *op3 = "7*3-7-4+1/3+6-8*2";
    char *pos1, *pos2, *pos3;
 
    pos1 = infix_to_postfix(op1);
    pos2 = infix_to_postfix(op2);
    pos3 = infix_to_postfix(op3);
 
    printf(" Result : %d\n", eval(pos1));
    printf(" Result : %d\n", eval(pos2));
    printf(" Result : %d\n", eval(pos3));
}

typedef字符元素；
类型定义结构{
元素堆栈[最大堆栈大小]；
int top；
}堆垛式；
void init（堆栈类型*s）{
s->top=-1；
}
int为空（StackType*s）{
返回（s->top==-1）；
}
整数已满（堆栈类型*s）{
返回（s->top==（最大堆栈大小-1））；
}
无效推送（堆栈类型*s，元素项）{
如果（已满）{
fprintf（stderr，“完整堆栈错误”\n）；
返回；
}
else s->stack[++（s->top）]=物料；
}
元素pop（堆栈类型*s）{
如果（u为空）{
fprintf（stderr，“空堆栈错误\n”）；
出口（1）；
}
否则返回s->stack[（s->top）--]；
}
int eval（字符表达式[]）{
int op1，op2，值，i=0；
int len=strlen（exp）；
char ch；
stacks型；
初始化（&s）；
对于（i=0；i当（！is__empty（&s）&&（prec（ch）时，线索是
61+195=256
。这意味着在某个地方，您的计算正在保存到chars。看起来它是
元素

typedef element int;

线索是
61+195=256
。这意味着在某个地方，您的计算正在保存到chars。看起来是
element

typedef element int;

与您的问题无关，但即使字符串以null结尾，也不意味着
null
null
用于null指针。null结尾字符可以是
'\0'
或其等效整数
0
。对于您的问题，请花一些时间阅读，并学习如何使用调试器执行步骤在监视变量及其值的同时逐行检查代码。此外，我建议您打印出例如
pos2
，以确保后缀表达式正确。嗯……有趣的是
-61+256==195
。签名溢出？@Someprogrammerdude谢谢您的建议！代码来自数据结构教程在C中，我添加了一些部分来制作一个prgoram，该prgoram具有自己的功能。这与您的问题无关，但即使字符串以null结尾，也并不意味着
null
null

用于null指针。null结尾字符可以是

'\0'

或其等效整数

0

贝姆，请花点时间阅读，并学习如何使用调试器在监视变量及其值的同时逐行检查代码。此外，我建议您打印出例如

pos2

，以确保后缀表达式正确。嗯……有趣的是

-61+256==195

。签名溢出？@someprogramrdude谢谢你的建议！代码来自一本C语言数据结构的教程。我添加了一些部分来制作一个prgoram，它有自己的功能。谢谢！我把“char”改成了“int”，效果很好。我忘了我不是为了制作程序才改了这个部分的……谢谢！我把“char”改成了“int”，效果很好。我忘了我没有改变角色来制作这个节目。。。