在堆栈顶部推送任何超过 127 的数字后，代码将停止工作

Question

C 语言程序!

对于我的家庭作业，我必须编写一个程序，通过使用 ADT Stack 来查找前缀中给出的算术表达式的值。输入是一个字符串，例如“- + 5 12 * 7 3”，输出将为“-4”。

我解决了我的作业，我认为一切都很好。但由于某种原因，当我将数字压入堆栈顶部时，如果数字大于或等于 128，或者低于或等于 -128，则一旦压入堆栈，数字就会完全改变。例如，如果我将 129 压入堆栈，当我从顶部检索数字时，它已变为 -127。

该程序有超过 150 行代码，所以我不知道如果我将其发布在这里会有多大帮助，我只是好奇是否有人知道为什么会发生这种情况。

(这是我的程序的简要说明:输入是一个字符串，其中数字和运算符用空格分隔。

计算中缀的程序是这样的:从字符串末尾的字符开始，从结尾到开头。如果 char 是数字，首先找到整数(直到空白)，然后将其压入堆栈(作为 int，而不是作为 char)。如果 char 是运算符，则从堆栈中删除最后两个数字并对它们进行操作，然后将其推回堆栈。堆栈上的最后一个数字就是结果。

我知道这真的很模糊，所以如果整个程序有更多帮助，我会发布它。所有的操作都是正确的，我检查了一下，当我把它们放在堆栈上时，问题就特别出现了。另外，我使用指针实现了字符串。)

编辑:我将输出改为“-4”，而不是“4”。我的错!

编辑:代码:(另外，我使用 int 作为我的数据类型。)

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

typedef struct _element{
    int c;
    struct _element *next;
}element;

typedef element *stack;

void StMakeNull(stack *Sp){
    *Sp=NULL;
}

int StEmpty(stack S){
    if(S==NULL) return 1;
    else return 0;
}

void StPush(stack *Sp, char d){
    element *temp;
    temp=(*Sp);
    (*Sp)=(element*)malloc(sizeof(element));
    (*Sp)->c=d;
    (*Sp)->next=temp;
}

void StPop(stack *Sp){
    if(StEmpty(*Sp)) exit(202);
    else{
        element *temp;
        temp=(*Sp);
        (*Sp)=(*Sp)->next;
        free(temp);
    }
}

char StTop(stack S){
    if(StEmpty(S)) exit(202);
    return S->c;
}

int Jel_broj(char c){
    int d=c;
    if(d>=48 && d<=57)
        return 1;
    return 0;
}

int Jel_operator(char c){
    if(c=='+') return 1;
    else if(c=='-') return 2;
    else if(c=='*') return 3;
    else if(c=='/') return 4;
    else if(c=='^') return 5;
    return 0;
}

int pot(int n, int k){
    int l=1;
    while(k>0){
        l*=n;
        k--;
    }
    return l;
}

void izracunaj(char* niz, int n){
    int broj=0, pomocni, j, nn, b1, b2;
    stack S;
    StMakeNull(&S);
    while(n>=0){
        if(Jel_broj(niz[n])){
            broj=0; j=0; nn=n;
            while(Jel_broj(niz[nn])){
                j++;
                nn--;
            }
            nn=j;
            while(Jel_broj(niz[n-j+1])){
                pomocni=niz[n-j+1];
                broj=broj*10+(pomocni-'0');
                j--;
            }
            StPush(&S, broj);
            n=n-nn+1;
        }
        else if(Jel_operator(niz[n])){
            if(Jel_operator(niz[n])==1){
                b1=StTop(S);
                StPop(&S);
                b2=StTop(S);
                StPop(&S);
                StPush(&S, b1+b2);
            }
            else if(Jel_operator(niz[n])==2){
                b1=StTop(S);
                StPop(&S);
                b2=StTop(S);
                StPop(&S);
                StPush(&S, b1-b2);
            }
            else if(Jel_operator(niz[n])==3){
                b1=StTop(S);
                StPop(&S);
                b2=StTop(S);
                StPop(&S);
                StPush(&S, b1*b2);
            }
            else if(Jel_operator(niz[n])==4){
                b1=StTop(S);
                StPop(&S);
                b2=StTop(S);
                StPop(&S);
                StPush(&S, b1/b2);
            }
            else if(Jel_operator(niz[n])==5){
                b1=StTop(S);
                StPop(&S);
                b2=StTop(S);
                StPop(&S);
                StPush(&S, pot(b1,b2));
            }
        }
        n--;
    }
    printf("%d", StTop(S));
}

int main(){
    char *niz=NULL;
    int n=0;
    char c;
    while(1){
        scanf("%c", &c);
        if(c=='\n'){
            niz=(char*)realloc(niz, (++n)*sizeof(char));
            niz[n-1]='\0';
            break;
        }
        niz=(char*)realloc(niz, (++n)*sizeof(char));
        niz[n-1]=c;
    }
    izracunaj(niz,n-2);
    return 0;
}

Answer 1

您可能将这些值存储为 int，但当您将它们放入和取出堆栈时，它们会被截断为 char 值。

void StPush(stack *Sp, char d)
char StTop(stack S)