用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()，编写源程序中的 ​​​​double deal_exp (char *exp) 函数，对这个算术表达式求值，返回结果，不使用栈和递归

好的，这个问题可以使用表达式解析（Expression Parsing）技术来解决。

表达式解析是指将一个算术表达式转换成一个语法树，然后对语法树进行求值的过程。具体来说，我们可以使用递归下降法（Recursive Descent Parsing）来进行表达式解析。

递归下降法是一种自顶向下的语法分析方法，它通过递归调用函数来解析语法。对于一个算术表达式，我们可以定义如下的语法规则：

expr      -> term { ("+" | "-") term }*
term      -> factor { ("*" | "/") factor }*
factor    -> "(" expr ")" | number
number    -> digit { digit }
digit     -> "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

按照上述语法规则，我们可以编写一个递归下降的表达式解析器。具体来说，我们可以定义如下的函数：

- `eval_expr()`：对一个表达式求值。
- `eval_term()`：对一个项求值。
- `eval_factor()`：对一个因子求值。
- `eval_number()`：将一个数字字符串转换成一个整数。

下面是具体的源代码实现：

#include <cstring>

using namespace std;

int eval_number(char *exp, int &pos) {
    int len = strlen(exp);
    int num = 0;
    while (pos < len && isdigit(exp[pos])) {
        num = num * 10 + (exp[pos] - '0');
        pos++;
    }
    return num;
}

int eval_factor(char *exp, int &pos) {
    int num = 0;
    if (exp[pos] == '(') {
        pos++;
        num = eval_expr(exp, pos);
        pos++;  // skip ')'
    }
    else {
        num = eval_number(exp, pos);
    }
    return num;
}

int eval_term(char *exp, int &pos) {
    int num1 = eval_factor(exp, pos);
    while (pos < strlen(exp) && (exp[pos] == '*' || exp[pos] == '/')) {
        char op = exp[pos];
        pos++;
        int num2 = eval_factor(exp, pos);
        if (op == '*') {
            num1 *= num2;
        }
        else {
            num1 /= num2;
        }
    }
    return num1;
}

int eval_expr(char *exp, int &pos) {
    int num1 = eval_term(exp, pos);
    while (pos < strlen(exp) && (exp[pos] == '+' || exp[pos] == '-')) {
        char op = exp[pos];
        pos++;
        int num2 = eval_term(exp, pos);
        if (op == '+') {
            num1 += num2;
        }
        else {
            num1 -= num2;
        }
    }
    return num1;
}

double deal_exp(char *exp) {
    int pos = 0;
    int res = eval_expr(exp, pos);
    return res;
}

使用这个函数，我们可以方便地对一个算术表达式求值，而不需要使用栈和递归。