用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()。 ​​​​​ 编写源程序中的 ​​​​double deal_exp (char *exp) 函数，对这个算术表达式求值，返回结果。不限制方法，你可以用“原始”的多遍扫描字符串，也可以用先进一点的栈（本课程前面接触的栈都是操作系统提供给程序以实现局部变量定义和函数调用的，现在你需要自己创建并使用栈了）。为便于集中精力在功能方面，可以不用检查用户输入的合法性。（请你逐步解释一下代码

）首先，我们需要定义一个栈的结构体，包含栈顶指针和栈的大小，可以这样定义：

typedef struct Stack {
    int top;
    int size;
    double *data;
} Stack;

接着，我们需要实现一些栈的基本操作，如入栈、出栈、判断栈是否为空等等，可以这样实现：

void push(Stack *s, double val) {
    s->data[++(s->top)] = val;
}

double pop(Stack *s) {
    return s->data[(s->top)--];
}

int isEmpty(Stack *s) {
    return s->top == -1;
}

接下来，我们需要实现对算术表达式的求值，可以采用中缀表达式转后缀表达式的方法，再通过后缀表达式求值。具体步骤如下：

1. 定义两个栈，分别为`operatorStack`和`numberStack`，`operatorStack`用于存储运算符，`numberStack`用于存储数字。
2. 从左到右遍历表达式，遇到数字则压入`numberStack`，遇到运算符则进行如下处理：
- 如果`operatorStack`为空或者栈顶元素为左括号，则直接将该运算符压入`operatorStack`；
- 如果该运算符的优先级比栈顶运算符的优先级高，则将该运算符压入`operatorStack`；
- 否则，将`operatorStack`栈顶元素弹出并压入`numberStack`，直到该运算符可以压入`operatorStack`。
3. 遍历完表达式后，将`operatorStack`中的所有运算符依次弹出并压入`numberStack`。
4. 此时`numberStack`中的元素就是后缀表达式，我们可以通过遍历后缀表达式进行求值，具体步骤如下：
- 从左到右遍历后缀表达式，遇到数字则压入`numberStack`，遇到运算符则弹出`numberStack`栈顶的两个元素，进行相应的运算，并将结果压入`numberStack`。
- 遍历完后缀表达式后，`numberStack`中只剩下一个元素，即为表达式的值。

最终，我们可以这样实现`deal_exp`函数：

double deal_exp(char *exp) {
    Stack operatorStack = { -1, strlen(exp), (double*)malloc(sizeof(double)*strlen(exp)) };
    Stack numberStack = { -1, strlen(exp), (double*)malloc(sizeof(double)*strlen(exp)) };
    char *p = exp;
    while (*p != '\0') {
        if (*p >= '0' && *p <= '9') {
            double num = 0;
            int flag = 1;
            if (p != exp && (*(p - 1) == '-' || *(p - 1) == '+')) {
                if (*(p - 1) == '-') {
                    flag = -1;
                }
                p--;
                while (p >= exp && (*p >= '0' && *p <= '9')) {
                    num += (*p - '0')*pow(10, exp - p - 1);
                    p--;
                }
                push(&numberStack, flag*num);
                p++;
            }
            else {
                while (*p >= '0' && *p <= '9') {
                    num = num * 10 + (*p - '0');
                    p++;
                }
                push(&numberStack, flag*num);
            }
        }
        else if (*p == '+' || *p == '-' || *p == '*' || *p == '/') {
            while (!isEmpty(&operatorStack) && operatorStack.data[operatorStack.top] != '(' && ((operatorStack.data[operatorStack.top] == '*' || operatorStack.data[operatorStack.top] == '/') || (*p == '+' || *p == '-'))) {
                double b = pop(&numberStack);
                double a = pop(&numberStack);
                switch ((char)pop(&operatorStack)) {
                case '+':
                    push(&numberStack, a + b);
                    break;
                case '-':
                    push(&numberStack, a - b);
                    break;
                case '*':
                    push(&numberStack, a * b);
                    break;
                case '/':
                    push(&numberStack, a / b);
                    break;
                }
            }
            push(&operatorStack, (double)(*p));
            p++;
        }
        else if (*p == '(') {
            push(&operatorStack, (double)(*p));
            p++;
        }
        else if (*p == ')') {
            while (operatorStack.data[operatorStack.top] != '(') {
                double b = pop(&numberStack);
                double a = pop(&numberStack);
                switch ((char)pop(&operatorStack)) {
                case '+':
                    push(&numberStack, a + b);
                    break;
                case '-':
                    push(&numberStack, a - b);
                    break;
                case '*':
                    push(&numberStack, a * b);
                    break;
                case '/':
                    push(&numberStack, a / b);
                    break;
                }
            }
            pop(&operatorStack);
            p++;
        }
        else {
            p++;
        }
    }
    while (!isEmpty(&operatorStack)) {
        double b = pop(&numberStack);
        double a = pop(&numberStack);
        switch ((char)pop(&operatorStack)) {
        case '+':
            push(&numberStack, a + b);
            break;
        case '-':
            push(&numberStack, a - b);
            break;
        case '*':
            push(&numberStack, a * b);
            break;
        case '/':
            push(&numberStack, a / b);
            break;
        }
    }
    return pop(&numberStack);
}

需要注意的是，我们在处理负数时需要进行特殊处理，即判断当前字符是否为数字，如果是，则往前找到第一个非数字字符，并将中间的数字解析为一个数，并根据前一个字符的符号进行处理。