C语言编写的计算器源代码

C语言编写的计算器源代码
```c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#define MAX_EXPRESSION_SIZE 100
//栈结构定义
typedef struct
int top;
double data[MAX_EXPRESSION_SIZE];
} Stack;
//初始化栈
void initStack(Stack *s)
s->top = -1;
//入栈
void push(Stack *s, double value)
if (s->top == MAX_EXPRESSION_SIZE - 1)
printf("Stack is full. Cannot push element.\n");
} else
s->data[++(s->top)] = value;
}
//出栈
double pop(Stack *s)
if (s->top == -1)
printf("Stack is empty. Cannot pop element.\n"); return -1;
} else
return s->data[(s->top)--];
}
//获取栈顶元素
double peek(Stack *s)
if (s->top == -1)
return -1;
} else
return s->data[s->top];
}
//判断运算符的优先级
int getPriority(char operator)
switch (operator)
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
case '^':
return 3;
default:
return -1;
}
//执行四则运算
double performOperation(double operand1, double operand2, char operator)
switch (operator)
case '+':
return operand1 + operand2;
case '-':
return operand1 - operand2;
case '*':
return operand1 * operand2;
case '/':
if (operand2 != 0)
return operand1 / operand2;
} else
printf("Error: Division by zero.\n");
exit(1);
}
case '^':
return pow(operand1, operand2);
default:
return 0;
}
//计算表达式结果
double evaluateExpression(char *expression) Stack operandStack;
Stack operatorStack;
initStack(&operandStack);
initStack(&operatorStack);
int length = strlen(expression);
for (int i = 0; i < length; i++)
//忽略空格
if (expression[i] == ' ')
continue;
}
//数字直接入栈
if (isdigit(expression[i]))
double num = 0;
while (i < length && (isdigit(expression[i]) ， expression[i] == '.'))
num = num * 10 + (expression[i] - '0');
i++;
}
i--;
push(&operandStack, num);
}
//左括号入栈
else if (expression[i] == '(')
push(&operatorStack, expression[i]);
}
//右括号出栈并执行运算，直到遇到左括号
else if (expression[i] == ')')
while (peek(&operatorStack) != '(')
double operand2 = pop(&operandStack);
double operand1 = pop(&operandStack);
char operator = pop(&operatorStack);
double result = performOperation(operand1, operand2, operator);
push(&operandStack, result);
}
pop(&operatorStack);
}
//运算符出栈并执行运算，直到栈空或者遇到优先级较低的运算符else
while (peek(&operatorStack) != -1 &&
getPriority(expression[i]) <= getPriority(peek(&operatorStack))) double operand2 = pop(&operandStack);
double operand1 = pop(&operandStack);
char operator = pop(&operatorStack);
double result = performOperation(operand1, operand2, operator);
push(&operandStack, result);
}
push(&operatorStack, expression[i]);
}
}
//处理剩下的运算符
while (peek(&operatorStack) != -1)
double operand2 = pop(&operandStack);
double operand1 = pop(&operandStack);
char operator = pop(&operatorStack);
double result = performOperation(operand1, operand2, operator);
push(&operandStack, result);
}
return pop(&operandStack); // 返回最终结果
int mai
char expression[MAX_EXPRESSION_SIZE];
printf("Enter an arithmetic expression: ");
fgets(expression, MAX_EXPRESSION_SIZE, stdin);
double result = evaluateExpression(expression);
printf("Result = %.2f\n", result);
return 0;
```
这个计算器可以实现基本的四则运算，支持括号和浮点数。

运行时，用户需要输入一个算术表达式，然后计算器会输出结果。

计算器使用两个栈来实现表达式的求值，一个栈用于存储操作数，另一个栈用于存储运算符。

通过比较运算符的优先级，可以确保表达式求值的正确顺序。