C段错误（堆芯转储）中带堆栈的计算器

我想做一个能用逻辑运算符计算的计算器。我创建了两个堆栈，一个用于1和0，另一个用于运算符。我也可以编译，但当我想尝试时，会说：“分段错误（核心转储）”。先谢谢你

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

#include <Stack.h>

#define MAX_EXPR_SIZE 100

int Evaluate01(char *expr) {
    int final, i = 0;

    Stack *stack1 = (Stack *)malloc(sizeof(Stack));
    Stack *stack2 = (Stack *)malloc(sizeof(Stack));
    if(!stack1 || !stack2) {
       //print error and return
    }

    Stack_initialize(stack1);
    Stack_initialize(stack2);


    do {

        if (expr[i] == '0' || expr[i] == '1'){
            int foo3 = expr[i] - '0';
            Stack_Push(stack1, foo3);
        }

        else if (expr[i] == 0x96){
            int foo3 = Stack_Pop(stack1);
            int sum = !foo3;
            Stack_Push(stack1, sum);
        }

        else if (expr[i] == 0x62 ||
                 expr[i] == 0x46 ||
                 expr[i] == 0x43 ||
                 expr[i] == 'x'){

            Stack_Push(stack2, expr[i]);
        }   

        else if (expr[i] == 0x41){
            int sum;
            int foo1= Stack_Pop(stack1);
            int foo2 = Stack_Pop(stack1);
            char op = Stack_Pop(stack2);

            switch(op){
                case 0x62:
                    sum = !foo1 || foo2;
                    Stack_Push(stack1, sum);
                    break;

                case 0x46:
                    sum = foo1 && foo2;
                    Stack_Push(stack1, sum);
                    break;

                case 0x43:
                    sum = foo1 || foo2;
                    Stack_Push(stack1, sum);
                    break;

                case 'x':
                    sum = foo1 ^ foo2;
                    Stack_Push(stack1, sum);
                    break;
            }
        }

        i++;
    }while (expr[i] != '\0');
     final = Stack_Pop(stack1);
     free(stack1);
     free(stack2);
     return final;
}

int main(int argc, char *argv[]) {

    char expr[MAX_EXPR_SIZE+1];

    while(1) {

        printf("logical expression : ");
        scanf(" %s", expr);

        printf("results: ");
        printf("%d\n", Evaluate01(expr));
    }

    return 0;
}

#包括
#包括
#包括
#包括
#定义最大扩展大小100
int Evaluate01（字符*expr）{
int final，i=0；
Stack*stack1=（Stack*）malloc（sizeof（Stack））；
Stack*stack2=（Stack*）malloc（sizeof（Stack））；
如果（！stack1 | |！stack2）{
//打印错误和返回
}
Stack_初始化（stack1）；
Stack_初始化（stack2）；
做{
如果（expr[i]=“0”| expr[i]=“1”）{
int foo3=expr[i]-“0”；
堆栈推送（堆栈1，foo3）；
}
else if（expr[i]==0x96）{
int foo3=堆栈（堆栈1）；
整数和=！foo3；
堆栈推送（堆栈1，总和）；
}
else如果（expr[i]==0x62||
expr[i]==0x46||
expr[i]==0x43||
expr[i]=“x”）{
堆栈推送（堆栈2，表达式[i]）；
}   
else if（expr[i]==0x41）{
整数和；
int foo1=堆栈（堆栈1）；
int foo2=堆栈_Pop（堆栈1）；
char op=堆栈_Pop（堆栈2）；
开关（op）{
案例0x62：
总和=！foo1 | | foo2；
堆栈推送（堆栈1，总和）；
打破
案例0x46：
总和=foo1&&foo2；
堆栈推送（堆栈1，总和）；
打破
案例0x43：
总和=foo1 | | foo2；
堆栈推送（堆栈1，总和）；
打破
案例“x”：
总和=foo1^foo2；
堆栈推送（堆栈1，总和）；
打破
}
}
i++；
}while（expr[i]！='\0'）；
最终=堆栈_Pop（堆栈1）；
免费（stack1）；
免费（2）；
返回最终结果；
}
int main（int argc，char*argv[]）{
字符表达式[最大表达式大小+1]；
而(1){
printf（“逻辑表达式：”）；
scanf（“%s”，expr）；
printf（“结果：”）；
printf（“%d\n”，Evaluate01（expr））；
}
返回0；
}

---

编辑：现在它正在工作。非常感谢你

首先，在使用字符与其ascii值之间的比较时，应使用十六进制。例如：

expr[i] == 62

应写为：

expr[i] == 0x62

第二，在将字符转换为int时，应该使用atoi

此外，您应该首先检查分配是否成功。 最后，while迭代应该循环while expr[i]！=空

代码：

#包括
#包括
#包括
#包括
#定义最大扩展大小100
int Evaluate01（字符*expr）{
int i=0；
Stack*stack1=（Stack*）malloc（sizeof（Stack））；
Stack*stack2=（Stack*）malloc（sizeof（Stack））；
如果（！stack1 | |！stack2）{
//打印错误和返回
}
Stack_初始化（stack1）；
Stack_初始化（stack2）；
做{
如果（expr[i]=“0”| expr[i]=“1”）{
int foo3=atoi（expr[i]-“0”）；
堆栈推送（堆栈1，foo3）；
}
else if（expr[i]==0x96）{
int foo3=堆栈（堆栈1）；
整数和=！foo3；
堆栈推送（堆栈1，总和）；
}
else如果（expr[i]==0x62||
expr[i]==0x46||
expr[i]==0x43||
expr[i]==0x120）{
堆栈推送（堆栈2，表达式[i]）；
}   
else if（expr[i]==0x41）{
整数和；
int foo1=堆栈（堆栈1）；
int foo2=堆栈_Pop（堆栈1）；
char op=堆栈_Pop（堆栈2）；
开关（op）{
案例0x62：
总和=！foo1 | | foo2；
堆栈推送（堆栈1，总和）；
打破
案例0x46：
总和=foo1&&foo2；
堆栈推送（堆栈1，总和）；
打破
案例0x43：
总和=foo1 | | foo2；
堆栈推送（堆栈1，总和）；
打破
案例0x120：
总和=foo1^foo2；
堆栈推送（堆栈1，总和）；
打破
}
}
i++；
}while（expr[i]！=NULL）；
免费（stack1）；
免费（2）；
}
int main（int argc，char*argv[]）{
字符表达式[最大表达式大小+1]；
而(1){
printf（“逻辑表达式：”）；
scanf（“%s”，expr）；
printf（“结果：”）；
printf（“%d\n”，Evaluate01（expr））；
}
返回0；
}

您的while语句似乎永远正确。我找不到更改expr值的行。

Evaluate01

不返回值this

}而（expr！=NULL）

可能需要是

}而（expr[i]！=0）。如果要使用do while循环，则需要检查
expr
是否至少包含一个字符。
while（expr[i]！=0）不起作用，我不知道如何结束while语句。哪一行导致分段错误？您是否使用GDB或Valgrind/Dr内存运行此测试？atoi不使用字符串作为参数吗？这将如何工作
intfoo3=atoi（expr[i]-“0”）？我的错，你应该把它转换成字符串。char-str[2]；str[0]=expr[i]-“0”；str[1]=“0”；如果你只是想把一个字符转换成它的整数表示，我不明白你为什么需要atoi。而且，
str[0]=expr[i]-“0”应该是
str[0]=expr[i]如果要使用atoi。
bool01.c:72:21：警告：指针和整数之间的比较}while（expr[i]！=NULL）无法完成此操作statement@Rufustry:while（expr[i]！=“\0”）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Stack.h>

#define MAX_EXPR_SIZE 100

int Evaluate01(char *expr) {
    int i = 0;
    Stack *stack1 = (Stack *)malloc(sizeof(Stack));
    Stack *stack2 = (Stack *)malloc(sizeof(Stack));
    if(!stack1 || !stack2) {
       //print error and return
    }

    Stack_initialize(stack1);
    Stack_initialize(stack2);


    do {

        if (expr[i] == '0' || expr[i] == '1'){
            int foo3 = atoi(expr[i] - '0');
            Stack_Push(stack1, foo3);
        }

        else if (expr[i] == 0x96){
            int foo3 = Stack_Pop(stack1);
            int sum = !foo3;
            Stack_Push(stack1, sum);
        }

        else if (expr[i] == 0x62 ||
                 expr[i] == 0x46 ||
                 expr[i] == 0x43 ||
                 expr[i] == 0x120){

            Stack_Push(stack2, expr[i]);
        }   

        else if (expr[i] == 0x41){
            int sum;
            int foo1= Stack_Pop(stack1);
            int foo2 = Stack_Pop(stack1);
            char op = Stack_Pop(stack2);

            switch(op){
                case 0x62:
                    sum = !foo1 || foo2;
                    Stack_Push(stack1, sum);
                    break;

                case 0x46:
                    sum = foo1 && foo2;
                    Stack_Push(stack1, sum);
                    break;

                case 0x43:
                    sum = foo1 || foo2;
                    Stack_Push(stack1, sum);
                    break;

                case 0x120:
                    sum = foo1 ^ foo2;
                    Stack_Push(stack1, sum);
                    break;
            }
        }

        i++;
    }while (expr[i] != NULL);

    free(stack1);
    free(stack2);
}

int main(int argc, char *argv[]) {

    char expr[MAX_EXPR_SIZE+1];

    while(1) {

        printf("logical expression : ");
        scanf(" %s", expr);

        printf("results: ");
        printf("%d\n", Evaluate01(expr));
    }

    return 0;
}