写一个c语言代码，计算一个含括号的数学表达式，当输入#时输入停止，输出表达式的结果

一个数学表达式时，代码可以自动计算出表达式的结果。

提示：

1. 可以使用栈来实现括号的匹配，以及计算表达式的操作符。

2. 可以使用字符串来存储输入的表达式。

3. 代码需要考虑表达式中含有小数或负数的情况。

4. 可以在代码中使用标准库提供的数学函数库，如sin、cos等函数。

以下是一个可能的代码实现：

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

#define MAX_SIZE 100

typedef struct {
int top;
double data[MAX_SIZE];
} Stack;

// 初始化栈
void initStack(Stack *s) {
s->top = -1;
}

// 判断栈是否为空
int isEmpty(Stack *s) {
return s->top == -1;
}

// 判断栈是否已满
int isFull(Stack *s) {
return s->top == MAX_SIZE - 1;
}

// 入栈
void push(Stack *s, double x) {
if (isFull(s)) {
printf("Stack overflow!\n");
exit(1);
}
s->data[++s->top] = x;
}

// 出栈
double pop(Stack *s) {
if (isEmpty(s)) {
printf("Stack underflow!\n");
exit(1);
}
return s->data[s->top--];
}

// 获取栈顶元素
double peek(Stack *s) {
if (isEmpty(s)) {
printf("Stack underflow!\n");
exit(1);
}
return s->data[s->top];
}

// 判断一个字符是否是数字
int isDigit(char c) {
return c >= '0' && c <= '9';
}

// 判断一个字符是否是操作符
int isOperator(char c) {
return c == '+' || c == '-' || c == '*' || c == '/';
}

// 判断一个字符是否是左括号
int isLeftParen(char c) {
return c == '(';
}

// 判断一个字符是否是右括号
int isRightParen(char c) {
return c == ')';
}

// 获取操作符的优先级
int getPriority(char op) {
if (op == '+' || op == '-') {
return 1;
} else if (op == '*' || op == '/') {
return 2;
} else {
return 0;
}
}

// 计算两个数字的结果
double calculate(double x, double y, char op) {
switch (op) {
case '+':
return x + y;
case '-':
return x - y;
case '*':
return x * y;
case '/':
return x / y;
default:
printf("Invalid operator!\n");
exit(1);
}
}

// 计算表达式的值
double evaluate(char *expr, int len) {
Stack operandStack; // 操作数栈
Stack operatorStack; // 操作符栈
initStack(&operandStack);
initStack(&operatorStack);

for (int i = 0; i < len; i++) {
char c = expr[i];
if (isDigit(c)) {
// 如果是数字，则将其转换为double类型并入栈
double num = c - '0';
i++;
while (i < len && isDigit(expr[i])) {
num = num * 10 + (expr[i] - '0');
i++;
}
if (i < len && expr[i] == '.') {
double frac = 0.1;
i++;
while (i < len && isDigit(expr[i])) {
num = num + frac * (expr[i] - '0');
frac = frac / 10;
i++;
}
}
if (i < len && expr[i] == 'E') {
i++;
int sign = 1;
if (expr[i] == '+') {
i++;
} else if (expr[i] == '-') {
sign = -1;
i++;
}
int exp = 0;
while (i < len && isDigit(expr[i])) {
exp = exp * 10 + (expr[i] - '0');
i++;
}
num = num * pow(10, sign * exp);
}
push(&operandStack, num);
i--;
} else if (isOperator(c)) {
// 如果是操作符，则将其与操作符栈中的操作符比较优先级，并执行相应计算
while (!isEmpty(&operatorStack) && isOperator(peek(&operatorStack)) &&
getPriority(c) <= getPriority(peek(&operatorStack))) {
char op = pop(&operatorStack);
double y = pop(&operandStack);
double x = pop(&operandStack);
double result = calculate(x, y, op);
push(&operandStack, result);
}
push(&operatorStack, c);
} else if (isLeftParen(c)) {
// 如果是左括号，则入栈
push(&operatorStack, c);
} else if (isRightParen(c)) {
// 如果是右括号，则执行括号内的计算，并将结果入栈
while (!isEmpty(&operatorStack) && !isLeftParen(peek(&operatorStack))) {
char op = pop(&operatorStack);
double y = pop(&operandStack);
double x = pop(&operandStack);
double result = calculate(x, y, op);
push(&operandStack, result);
}
if (!isEmpty(&operatorStack) && isLeftParen(peek(&operatorStack))) {
pop(&operatorStack);
}
}
}

// 执行操作符栈中剩余的计算
while (!isEmpty(&operatorStack)) {
char op = pop(&operatorStack);
double y = pop(&operandStack);
double x = pop(&operandStack);
double result = calculate(x, y, op);
push(&operandStack, result);
}

// 返回操作数栈中最后剩余的元素，即表达式的值
return pop(&operandStack);
}

int main() {
char expr[MAX_SIZE];
printf("Please input a math expression: ");
scanf("%s", expr);
double result = evaluate(expr, strlen(expr));
printf("The result is: %f\n", result);
return 0;
}