计算器程序的一个错误，怎么改

计算器程序求改错


```c
#include <stdio.h>
#include <stdlib.h> 
#include <math.h>
#include <string.h> 

#define M 100
/*定义字符串的长度*/
#define DEBUG 0 
/*定义调试模式*/

typedef enum{
    OK=1,
    ERROR=0
}Status;

typedef enum{
    TRUE=1,
    FALSE=0
}Bool;

/*数据结构*/
typedef struct DataType{
    float dt;
    char dc;
}DataType;

/*链栈结构*/
typedef struct LinkStackNode{
    DataType data;
    struct LinkStackNode* next;
    int size;
}Stack;

Stack* Stack_Init(Stack* pStack);
/*参数：pStack是指向栈的指针 
 *返回：返回该指针 
 */
 
void Stack_Free(Stack* pStack);
/*参数：pStack是指向栈的指针 
 *返回：无 
 */ 

void Stack_Clear(Stack* pStack);
/*参数：pStack是指向栈的指针 
 *返回：无
 */ 

Bool Stack_IsEmpty(Stack* pStack);
/*参数：pStack是指向栈的指针 
 *返回：若栈为空则返回TRUE；否则返回FAlSE 
 */

Bool Stack_IsFull(Stack* pStack); 
/*参数：pStack是指向栈的指针 
 *返回：若栈为满则返回TRUE；否则返回FALSE 
 */ 
 
int Stack_Length(Stack* pStack);
/*参数：pStack是指向栈的指针 
 *返回：该栈的长度 
 */ 

Status Stack_GetTop(Stack* pStack,int f,int* d,char* c);
/*参数：pStack是指向栈的指针，f是用于选择取出字符的类型，d是指向数字的指针，c是指向符号的指针 
 *返回：如果栈为空则返回ERROR；否则返回OK
 */

Status Stack_Push(Stack* pStack,int d=0,char c=0);
/*参数：pStack是指向栈的指针，d是用于选择执行何种操作的数，c是用于判断的字符 
 *返回：成功执行入栈操作返回OK；否额返回ERROR 
 */
 
Status Stack_Pop(Stack* pStack);
/*参数：pStack是指向栈的指针 
 *返回：成功执行出栈操作返回OK；否则返回ERROR 
 */ 
 
Status Stack_Traverse(Stack* pStack,Status(*visit)());
/*参数：pStack是指向栈的指针 
 *返回：成功遍历返回OK；否则返回ERROR 
 */ 

void Stack_Destruct(Stack* pStack);
/*参数：pStack是指向栈的指针 
 *返回：无 
 */

Stack* Stack_Init(Stack* pStack){
    pStack=(Stack*)malloc(sizeof(Stack));
    pStack->next=0;
    return pStack;
}

void Stack_Free(Stack* pStack){
    Stack* p;
    while(pStack){
        p=pStack->next;
        free(pStack);
        pStack=p;
    }
}

/*void Stack_Clear(Stack* pStack){
    Stack* p;
    p=pStack->next=0;
    Stack->data=0;
} */

Bool Stack_IsEmpty(Stack* pStack){
    if (pStack==0||pStack->next==0){ 
        return TRUE;
    } 
    else{ 
        return FALSE;
    } 
}

int Stack_Length(Stack* pStack){
    return pStack->size;
}

Status Stack_GetTop(Stack* pStack,int f,float* d,char* c){      /*f=0表示int类型，其他值表示char*/
    Stack* p=0;
    if(pStack==0||pStack->next==0){ 
        return ERROR;
    } 
    p=pStack;
    while(p->next){
        p=p->next;
    }
    if(f==0){
        *d=p->data.dt;
    }
    else{
        *c=p->data.dc;
    }
    return OK;
}


Status Stack_Push(Stack* pStack,int d,char c){
    Stack* p,* t;
    t=(Stack*)malloc(sizeof(Stack));
    t->next=0;
    if(c==0){ 
        t->data.dt=d;
    } 
    else{ 
        t->data.dc=c;
    }
    if(pStack==0){
        pStack=t;
    }
    else{
        p=pStack;
        while(p->next){ 
            p=p->next;
        }
        p->next=t;
    }
    pStack->size++;
    return OK;
}

Status Stack_Pop(Stack* pStack){
    Stack* p,* t;
    if(pStack==0||pStack->next==0){
        return ERROR;
    } 
    p=pStack;
    t=p->next;
    while(t->next){
        p=p->next;
        t=t->next;
    }
    p->next=0;
    /*if (f==0){ 
        *d=p->data.dt;
    } 
    else{ 
        *c=p->data.dc;
    }*/ 
    pStack->size--; 
    free(t);
    return OK;
}

Status Stack_Traverse(Stack* pStack,Status (*visit)()){
    int i,j;
    j=Stack_Length(pStack);
    for(i=0;i<j;i++){
        if(visit()==ERROR){
            return ERROR;
        }
    }
    return OK;
}

float ConvertToFloat(char m[M],float r);
/*功能：将数字串转换为浮点数 
 *参数：m[M]是原数字串，r是浮点数即结果 
 *返回：返回结果浮点数r 
 */

int Judge(char x);
/*功能：判断运算符的类型并分级
 *参数：x是运算符的符号
 *返回：字符所代表的级数
 */

int Culculate(int x1, int x2, char s);
/*功能：执行计算
 *参数：x1是第一个数字
        x2是第二个数字
        s是运算符
 *返回：返回运算结果
 */

Status Check(char left, char right);
/*功能：判断左右括号是否匹配
 *参数：left是左括号，right是右括号
 *返回：若左右括号匹配返回OK，否则返回ERROR
 */

Status CharIsSymbol(char c);
/*功能：判断字符是运算符
 *参数：c是字符
 *返回：若c为运算符返回OK；否则返回ERROR
 */

Status CharIsNum(char d);
/*功能：判断字符是数字
 *参数：d是字符
 *返回：若d是数字返回OK；否则返回ERROR
 */

int DoSingleOperation(char s[]);
/*功能：执行一行字符的计算
 *参数：s[]是这一行字符串
 *返回：返回运算结果
 */
 
float ConvertToFloat(char m[M]){
    int i=0;
    float value=0;
    while(m[i]!='\0'&&m[i]!='.'){
        value=value*10+(m[i]-'0');
        i=i+1;
    }
    if(m[i]=='\0'){
        return value;
    }
    i=i+1;
    float weight=0.1;
    while(m[i]!='\0'){
        value=value+(m[i]-'0')*weight;
        weight=weight/10;
        i=i+1;
    }
    return value;
}

int Judge(char x){
    if (x == '('){
        return 4;
    }
    else if(x=='+'||x=='-'){
        return 1;
    }
    else if(x=='*'||x=='/'){
        return 2;
    }
    else if(x=='^'){
        return 3;
    }
    else if(x==')'){
        return 0;
    }
}

int Culculate(int x1, int x2, char s){
    int result = 0;
    switch (s){
        case '+':{
            result=x1+x2;
            break;
        }
        case '-':{
            result=x1-x2;
            break;
        }
        case '*':{
            result=x1*x2;
            break;
        }
        case '/':{
            result=x1/x2;
            break;
        }
        case '^':{
            result=pow((double)x1,x2);
            break;
        }
    }
    return result;
}

Status Check(char left,char right){
    if (left=='('&&right==')'){
        return OK;
    }
    else{
        return ERROR;
    }
}

Status CharIsSymbol(char c){
    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='^'){
        return OK;
    }
    else{
        return ERROR;
    }
}

Status CharIsNum(char d){
    if (d>='0'&&d<='9'){
        return OK;
    }
    else{
        return ERROR;
    }
}

int DoSingleOperation(char s[]){
    Stack* pIntStack=0;                        /*这个栈存放数字*/
    Stack* pSymbolStack=0;                     /*这个栈存放除括号外的符号*/
    Stack* pSymbolStack_2=0;                   /*这个栈存放括号*/
    Status sta;

    pIntStack=Stack_Init(pIntStack);
    pSymbolStack=Stack_Init(pSymbolStack);
    pSymbolStack_2=Stack_Init(pSymbolStack_2);

    int len,n;
    len=strlen(s);
    s[len]='#';
    len++;
    int i;
    float a,b,c=0,d=0;
    float topele_int;
    char topele_c;
    char x[M];
    char xnum[M];
    float m;
    for (i=0;i<len;i++){
        if (s[i]=='('){
            Stack_Push(pSymbolStack_2,0,s[i]);
        }
        else if(s[i]==')'){
            Stack_GetTop(pSymbolStack_2,1,&topele_int,&topele_c);
            if (Check(topele_c,s[i]) == 1) {
                Stack_Pop(pSymbolStack_2);
            }
            else {
                printf("括号不匹配");           /*判断括号是否匹配*/
                return 0;
            }
        }
    }
    i = 0;
    if (s[0]=='+'||s[0]=='-'||s[0]=='*'||s[0]=='/'||s[0]=='^'){
        printf("运算符不能在开头");             /*除括号外的运算符不能在字符串开始处*/
        return 0;
    }
    while (s[i]!='#'){
        if(CharIsNum(s[i])==OK){
            int index=0;
            while(1){
                if(CharIsNum(s[i])||s[i]=='.'){
                    xnum[index++]=s[i];
                    i++;
                }
                else{
                    break;
                }
            }
            xnum[index]='\0';
            m=ConvertToFloat(xnum);
            Stack_Push(pIntStack,m);
            continue;
        }
        else{
            char theta=s[i];
            while(Stack_IsEmpty(pSymbolStack)==0) {
                Stack_GetTop(pSymbolStack,1,0,&topele_c);
                if (topele_c=='('||Judge(topele_c)<Judge(s[i]))
                    break;
                Stack_GetTop(pIntStack,0,&a,0);
                Stack_Pop(pIntStack); 
                Stack_GetTop(pIntStack,0,&b,0);
                Stack_Pop(pIntStack);
                if (a==0&&topele_c=='/'){
                    printf("除数不能为0\n");                         /*判断除数是否为0，若为0则结束程序，否则继续运行*/
                    return 0;
                }
                c=Culculate(b,a,topele_c);
                Stack_Push(pIntStack,c);
                Stack_Pop(pSymbolStack);
            }
            sta=Stack_GetTop(pSymbolStack,1,0,&topele_c);
            if(sta==OK&&Judge(theta)== 0&&Judge(topele_c)==4) {
                Stack_Pop(pSymbolStack);
            }
            if (Judge(theta)!= 0) {
                Stack_Push(pSymbolStack,0,theta);
            }
            i++;
        }
    }
    while(Stack_IsEmpty(pSymbolStack)==0) {
        Stack_GetTop(pSymbolStack,1,0,&topele_c);
        Stack_GetTop(pIntStack,0,&a,0);
        Stack_Pop(pIntStack);
        Stack_GetTop(pIntStack,0,&b,0);
        Stack_Pop(pIntStack);
        if(a==0&&topele_c=='/') {
            printf("除数不能为0\n");                                /*判断除数是否为0，若为0则结束程序，否则继续运行*/
            return 0;
        }
        c=Culculate(b,a,topele_c);
        Stack_Push(pIntStack,c);
        Stack_Pop(pSymbolStack);
    }
    Stack_GetTop(pIntStack,0,&a,0);
    printf("%d\n",a);
    return a;
}

int main(){
    int i;
    printf("Please choose the mode of operation\nFrom file to file:0\tFrom the keyboard:1\n");
    scanf("%d",&i);
    switch(i){
        case 0:{
            char all[M]={0};
            int result=0;
            FILE *fp=fopen("C:/Users/zh/Desktop/1.txt","r");            /*以只读模式打开文件1*/ 
            if(fp==0){
                printf("The first txt can not be opened!");             /*若打开文件1失败，结束程序，否则继续运行*/ 
                return 0;
            }
            FILE *fp2=fopen("C:/Users/zh/Desktop/2.txt","w");           /*以写入模式打开文件2*/ 
            while(!feof(fp)){
                fgets(all,100,fp);                                      /*对文件1逐行读取，直到文件尾*/ 
                int len=strlen(all);
                if(len==0){                                             /*若为空行，则结束此次循环，开始执行下一行的程序*/ 
                    continue;          
                }
                if(all[len-1]=='\n'){
                    all[len-1]='\0';
                }
                printf("%s\n",all);
                result=DoSingleOperation(all);                          /*对读入的一行进行运算*/ 
                fprintf(fp2,"%d\n",result);                             /*对读入的一行的运算结果打印到文件2中*/ 
            }
            fclose(fp);                                                 /*关闭文件1*/ 
            fclose(fp2);                                                /*关闭文件2*/ 
            break;
        }
        case 1:{
            printf("Please input the exxpression\n");
            int j=0,result;
            char all[M]={0};
            char y;
            gets(all);
            /*while((y=getchar())!='\n'){
                all[j]=y;
                j++;
            }*/
            result=DoSingleOperation(all);
            printf("%d\n",result);
            break;
        }
        default:{
            printf("error number\n");
            break;
        }
    }
    return 0;
}

```

写回答
好问题 0 提建议
追加酬金
关注问题
分享
邀请回答
编辑收藏删除
收藏举报

3条回答默认最新

技术专家团-小桥流水 2022-12-06 14:11

关注

你这是又把函数声明给加上了啊，再同一个文件里且函数A的实现在其调用函数之前的时候，没必要再声明一遍。
这个代码里，有几个问题：
（1）函数的声明和实现函数中的参数类型不匹配，上面声明的是int，下面实现的变成了float
（2）结构体里定义的是float，那么再计算的时候、入栈和出栈的时候，都应该是float类型，而不应该是int类型。
代码修改如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h> 
#include <math.h>
#include <string.h> 
#define M 100
/*定义字符串的长度*/
#define DEBUG 0 
/*定义调试模式*/
typedef enum {
    OK = 1,
    ERROR = 0
}Status;
typedef enum {
    TRUE = 1,
    FALSE = 0
}Bool;
/*数据结构*/
typedef struct DataType {
    float dt;
    char dc;
}DataType;
/*链栈结构*/
typedef struct LinkStackNode {
    DataType data;
    struct LinkStackNode* next;
    int size;
}Stack;
Stack* Stack_Init(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：返回该指针
 */
void Stack_Free(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：无
 */
void Stack_Clear(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：无
 */
Bool Stack_IsEmpty(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：若栈为空则返回TRUE；否则返回FAlSE
 */
Bool Stack_IsFull(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：若栈为满则返回TRUE；否则返回FALSE
 */
int Stack_Length(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：该栈的长度
 */
Status Stack_GetTop(Stack* pStack, int f, float* d, char* c);
/*参数：pStack是指向栈的指针，f是用于选择取出字符的类型，d是指向数字的指针，c是指向符号的指针
 *返回：如果栈为空则返回ERROR；否则返回OK
 */
Status Stack_Push(Stack* pStack, float d = 0, char c = 0);
/*参数：pStack是指向栈的指针，d是用于选择执行何种操作的数，c是用于判断的字符
 *返回：成功执行入栈操作返回OK；否额返回ERROR
 */
Status Stack_Pop(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：成功执行出栈操作返回OK；否则返回ERROR
 */
Status Stack_Traverse(Stack* pStack, Status(*visit)());
/*参数：pStack是指向栈的指针
 *返回：成功遍历返回OK；否则返回ERROR
 */
void Stack_Destruct(Stack* pStack);
/*参数：pStack是指向栈的指针
 *返回：无
 */
Stack* Stack_Init(Stack* pStack) {
    pStack = (Stack*)malloc(sizeof(Stack));
    pStack->next = 0;
    return pStack;
}
void Stack_Free(Stack* pStack) {
    Stack* p;
    while (pStack) {
        p = pStack->next;
        free(pStack);
        pStack = p;
    }
}
/*void Stack_Clear(Stack* pStack){
    Stack* p;
    p=pStack->next=0;
    Stack->data=0;
} */
Bool Stack_IsEmpty(Stack* pStack) {
    if (pStack == 0 || pStack->next == 0) {
        return TRUE;
    }
    else {
        return FALSE;
    }
}
int Stack_Length(Stack* pStack) {
    return pStack->size;
}
Status Stack_GetTop(Stack* pStack, int f, float* d, char* c) {      /*f=0表示int类型，其他值表示char*/
    Stack* p = 0;
    if (pStack == 0 || pStack->next == 0) {
        return ERROR;
    }
    p = pStack;
    while (p->next) {
        p = p->next;
    }
    if (f == 0) {
        *d = p->data.dt;
    }
    else {
        *c = p->data.dc;
    }
    return OK;
}
Status Stack_Push(Stack* pStack, float d, char c) {
    Stack* p, * t;
    t = (Stack*)malloc(sizeof(Stack));
    t->next = 0;
    if (c == 0) {
        t->data.dt = d;
    }
    else {
        t->data.dc = c;
    }
    if (pStack == 0) {
        pStack = t;
    }
    else {
        p = pStack;
        while (p->next) {
            p = p->next;
        }
        p->next = t;
    }
    pStack->size++;
    return OK;
}
Status Stack_Pop(Stack* pStack) {
    Stack* p, * t;
    if (pStack == 0 || pStack->next == 0) {
        return ERROR;
    }
    p = pStack;
    t = p->next;
    while (t->next) {
        p = p->next;
        t = t->next;
    }
    p->next = 0;
    /*if (f==0){
        *d=p->data.dt;
    }
    else{
        *c=p->data.dc;
    }*/
    pStack->size--;
    free(t);
    return OK;
}
Status Stack_Traverse(Stack* pStack, Status(*visit)()) {
    int i, j;
    j = Stack_Length(pStack);
    for (i = 0; i < j; i++) {
        if (visit() == ERROR) {
            return ERROR;
        }
    }
    return OK;
}
float ConvertToFloat(char m[M]);
/*功能：将数字串转换为浮点数
 *参数：m[M]是原数字串，r是浮点数即结果
 *返回：返回结果浮点数r
 */
int Judge(char x);
/*功能：判断运算符的类型并分级
 *参数：x是运算符的符号
 *返回：字符所代表的级数
 */
float Culculate(float x1, float x2, char s);
/*功能：执行计算
 *参数：x1是第一个数字
        x2是第二个数字
        s是运算符
 *返回：返回运算结果
 */
Status Check(char left, char right);
/*功能：判断左右括号是否匹配
 *参数：left是左括号，right是右括号
 *返回：若左右括号匹配返回OK，否则返回ERROR
 */
Status CharIsSymbol(char c);
/*功能：判断字符是运算符
 *参数：c是字符
 *返回：若c为运算符返回OK；否则返回ERROR
 */
Status CharIsNum(char d);
/*功能：判断字符是数字
 *参数：d是字符
 *返回：若d是数字返回OK；否则返回ERROR
 */
int DoSingleOperation(char s[]);
/*功能：执行一行字符的计算
 *参数：s[]是这一行字符串
 *返回：返回运算结果
 */
float ConvertToFloat(char m[M]) {
    int i = 0;
    float value = 0;
    while (m[i] != '\0' && m[i] != '.') {
        value = value * 10 + (m[i] - '0');
        i = i + 1;
    }
    if (m[i] == '\0') {
        return value;
    }
    i = i + 1;
    float weight = 0.1;
    while (m[i] != '\0') {
        value = value + (m[i] - '0') * weight;
        weight = weight / 10;
        i = i + 1;
    }
    return value;
}
int Judge(char x) {
    if (x == '(') {
        return 4;
    }
    else if (x == '+' || x == '-') {
        return 1;
    }
    else if (x == '*' || x == '/') {
        return 2;
    }
    else if (x == '^') {
        return 3;
    }
    else if (x == ')') {
        return 0;
    }
}
float Culculate(float x1, float x2, char s) {
    float result = 0;
    switch (s) {
    case '+': {
        result = x1 + x2;
        break;
    }
    case '-': {
        result = x1 - x2;
        break;
    }
    case '*': {
        result = x1 * x2;
        break;
    }
    case '/': {
        result = x1 / x2;
        break;
    }
    case '^': {
        result = pow(x1, x2);
        break;
    }
    }
    return result;
}
Status Check(char left, char right) {
    if (left == '(' && right == ')') {
        return OK;
    }
    else {
        return ERROR;
    }
}
Status CharIsSymbol(char c) {
    if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')' || c == '^') {
        return OK;
    }
    else {
        return ERROR;
    }
}
Status CharIsNum(char d) {
    if (d >= '0' && d <= '9') {
        return OK;
    }
    else {
        return ERROR;
    }
}
int DoSingleOperation(char s[]) {
    Stack* pIntStack = 0;                        /*这个栈存放数字*/
    Stack* pSymbolStack = 0;                     /*这个栈存放除括号外的符号*/
    Stack* pSymbolStack_2 = 0;                   /*这个栈存放括号*/
    Status sta;
    pIntStack = Stack_Init(pIntStack);
    pSymbolStack = Stack_Init(pSymbolStack);
    pSymbolStack_2 = Stack_Init(pSymbolStack_2);
    int len, n;
    len = strlen(s);
    s[len] = '#';
    len++;
    int i;
    float a, b, c = 0, d = 0;
    float topele_int;
    char topele_c;
    char x[M];
    char xnum[M];
    float m;
    for (i = 0; i < len; i++) {
        if (s[i] == '(') {
            Stack_Push(pSymbolStack_2, 0, s[i]);
        }
        else if (s[i] == ')') {
            Stack_GetTop(pSymbolStack_2, 1, &topele_int, &topele_c);
            if (Check(topele_c, s[i]) == 1) {
                Stack_Pop(pSymbolStack_2);
            }
            else {
                printf("括号不匹配");           /*判断括号是否匹配*/
                return 0;
            }
        }
    }
    i = 0;
    if (s[0] == '+' || s[0] == '-' || s[0] == '*' || s[0] == '/' || s[0] == '^') {
        printf("运算符不能在开头");             /*除括号外的运算符不能在字符串开始处*/
        return 0;
    }
    while (s[i] != '#') {
        if (CharIsNum(s[i]) == OK) {
            int index = 0;
            while (1) {
                if (CharIsNum(s[i]) || s[i] == '.') {
                    xnum[index++] = s[i];
                    i++;
                }
                else {
                    break;
                }
            }
            xnum[index] = '\0';
            m = ConvertToFloat(xnum);
            Stack_Push(pIntStack, m);
            continue;
        }
        else {
            char theta = s[i];
            while (Stack_IsEmpty(pSymbolStack) == 0) {
                Stack_GetTop(pSymbolStack, 1, 0, &topele_c);
                if (topele_c == '(' || Judge(topele_c) < Judge(s[i]))
                    break;
                Stack_GetTop(pIntStack, 0, &a, 0);
                Stack_Pop(pIntStack);
                Stack_GetTop(pIntStack, 0, &b, 0);
                Stack_Pop(pIntStack);
                if (a == 0 && topele_c == '/') {
                    printf("除数不能为0\n");                         /*判断除数是否为0，若为0则结束程序，否则继续运行*/
                    return 0;
                }
                c = Culculate(b, a, topele_c);
                Stack_Push(pIntStack, c);
                Stack_Pop(pSymbolStack);
            }
            sta = Stack_GetTop(pSymbolStack, 1, 0, &topele_c);
            if (sta == OK && Judge(theta) == 0 && Judge(topele_c) == 4) {
                Stack_Pop(pSymbolStack);
            }
            if (Judge(theta) != 0) {
                Stack_Push(pSymbolStack, 0, theta);
            }
            i++;
        }
    }
    while (Stack_IsEmpty(pSymbolStack) == 0) {
        Stack_GetTop(pSymbolStack, 1, 0, &topele_c);
        Stack_GetTop(pIntStack, 0, &a, 0);
        Stack_Pop(pIntStack);
        Stack_GetTop(pIntStack, 0, &b, 0);
        Stack_Pop(pIntStack);
        if (a == 0 && topele_c == '/') {
            printf("除数不能为0\n");                                /*判断除数是否为0，若为0则结束程序，否则继续运行*/
            return 0;
        }
        c = Culculate(b, a, topele_c);
        Stack_Push(pIntStack, c);
        Stack_Pop(pSymbolStack);
    }
    Stack_GetTop(pIntStack, 0, &a, 0);
    printf("%d\n", a);
    return a;
}
int main() {
    int i;
    printf("Please choose the mode of operation\nFrom file to file:0\tFrom the keyboard:1\n");
    scanf("%d", &i);
    switch (i) {
    case 0: {
        char all[M] = { 0 };
        float result = 0;
        FILE* fp = fopen("C:/Users/zh/Desktop/1.txt", "r");            /*以只读模式打开文件1*/
        if (fp == 0) {
            printf("The first txt can not be opened!");             /*若打开文件1失败，结束程序，否则继续运行*/
            return 0;
        }
        FILE* fp2 = fopen("C:/Users/zh/Desktop/2.txt", "w");           /*以写入模式打开文件2*/
        while (!feof(fp)) {
            fgets(all, 100, fp);                                      /*对文件1逐行读取，直到文件尾*/
            int len = strlen(all);
            if (len == 0) {                                             /*若为空行，则结束此次循环，开始执行下一行的程序*/
                continue;
            }
            if (all[len - 1] == '\n') {
                all[len - 1] = '\0';
            }
            printf("%s\n", all);
            result = DoSingleOperation(all);                          /*对读入的一行进行运算*/
            fprintf(fp2, "%f\n", result);                             /*对读入的一行的运算结果打印到文件2中*/
        }
        fclose(fp);                                                 /*关闭文件1*/
        fclose(fp2);                                                /*关闭文件2*/
        break;
    }
    case 1: {
        printf("Please input the exxpression\n");
        int j = 0;
        float result;
        char all[M] = { 0 };
        char y;
        gets(all);
        /*while((y=getchar())!='\n'){
            all[j]=y;
            j++;
        }*/
        result = DoSingleOperation(all);
        printf("%f\n", result);
        break;
    }
    default: {
        printf("error number\n");
        break;
    }
    }
    return 0;
}

本回答被题主选为最佳回答 , 对您是否有帮助呢?

编辑记录

查看更多回答(2条)

报告相同问题？

关注问题

c++写一个计算器程序 c++ 有问必答
2022-04-11 14:15

回答 2 已采纳 class Operation { double m_numberA,m_numberB; public: double GetNumA() {return m_numberA;}
用switch语句编程设计一个简单的计算器程序 c语言有问必答
2021-10-16 20:43

回答 2 已采纳你题目的解答代码如下：（如有帮助，望采纳！谢谢! 点击我这个回答右上方的【采纳】按钮） #include <stdio.h> int main() { float a,b;
关于时间计算器的一个编程问题 c++
2022-12-10 23:40

回答 4 已采纳运行结果：代码： #include <iostream> using namespace std; int isleapyear(int y) { if(y%4==0 && y
一个简易的计算器 java小程序
2018-01-17 15:55

在本文中，我们将深入探讨如何创建一个简易的Java计算器程序，该程序具备基本的数学运算功能，如加、减、乘、除，还包括求平方根、取倒数、求余数以及清除操作。这个计算器的设计旨在提供用户友好的界面和简单易用的...
python设计一个简单计算器程序 python
2023-04-18 11:32

回答 3 已采纳 def caculate(data1,op,data2): if op == '+': return data1+data2 elif op == '-':
求帮忙用VB语言做一个计算器。小程序
2021-06-22 11:23

回答 3 已采纳这个源码可以借鉴，如果你下不了，我可以帮忙下载，希望能采纳 https://download.csdn.net/download/yuxing1234/842988?utm_source=iteye
Java语言如何编写一个多项式的计算器的程序，要求界面友好，并且画出程序框图开发语言
2020-06-03 17:54

回答 2 已采纳这个问题可以参考下 https://blog.csdn.net/qq_42316621/article/details/100095609
c#语言.Net框架可视化程序设计作业-计算器程序.rar
2021-11-19 15:34

在本项目中，我们关注的是一个使用C#编程语言实现的计算器程序，它构建于.NET框架之上，并且具有可视化用户界面。这个程序是基于Visual Studio（VS）开发环境设计的，利用了其强大的Windows Forms应用开发功能。让...
如何制作一个计算器程序，有点很难哦 c语言有问必答
2021-11-28 00:15

回答 4 已采纳你题目的解答代码如下： #include <stdio.h> #include <stdlib.h> #include <time.h> int main() {
用java写一个计算器小程序。 java
2021-07-19 20:33

回答 1 已采纳 package test; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.util.V
如何用Python开发一个小型计算器 python
2023-03-30 16:25

回答 2 已采纳 a = input()b = input()c = input()print(eval(a+c+b))
C语言简易计算器程序设计指南
2024-09-20 14:05

本文档介绍了用于帮助初学者学习 C 语言输入输出与算术计算方法的一个简单的计算器项目设计方案，重点放在掌握C的基本用法。主要内容包含了实现支持加、减、乘以及整数与小数相除的函数，让用户可以自定义进行数值和...
如何修改python这个编码计算器里的错误 python
2021-10-13 10:38

回答 1 已采纳错误信息告诉你很清楚了，当调用step，你应该返回'(0)+3'这个字符串，而不是int值回去仔细审题，再编代码，这代码写的乱糟糟的，integer都已经是全局静态变量了，你还一遍一遍return它干
xyz-language:一个最终成为编程语言的简单计算器
2021-07-08 17:54

XYZ语言是一个旨在发展为全面编程语言的简单计算器项目，它可能从基础的算术运算开始，逐步引入更复杂的语法结构和功能，以实现更广泛的应用场景。这个项目可能由Java语言实现，利用Java的面向对象特性来构建一个...
LabView图形化编程语言之计算器.zip
2023-04-02 16:39

在"LabView图形化编程语言之计算器"这个主题中，我们将深入探讨LabView如何用于创建一个基本的计算器应用，以及涉及到的相关技术。 1. **图形化编程**：LabView的核心在于其可视化编程环境，用户通过拖拽和连接图标...
没有解决我的问题, 去提问

问题事件

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
系统已结题 6月16日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
已采纳回答 6月8日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
创建了问题 12月6日

悬赏问题

¥15 javaweb项目无法正常跳转
¥15 VMBox虚拟机无法访问
¥15 skd显示找不到头文件
¥15 机器视觉中图片中长度与真实长度的关系
¥15 fastreport table 怎么只让每页的最下面和最顶部有横线
¥15 R语言卸载之后无法重装，显示电脑存在下载某些较大二进制文件行为，怎么办
¥15 java 的protected权限，问题在注释里
¥15 这个是哪里有问题啊？
¥15 关于#vue.js#的问题：修改用户信息功能图片无法回显，数据库中只存了一张图片（相关搜索：字符串）
¥15 texstudio的问题，

计算器程序的一个错误，怎么改

3条回答 默认 最新

问题事件

悬赏问题

3条回答默认最新