c语言实现使用算符优先分析方法设计一个计算器，必须能够完成加、减、乘、除、幂、括号（）等运算符；给定任意符号串，判断其是否是正确的表达式，若是给出计算结果；写出具体代码

### 回答1：

根据要求，可以使用算符优先分析法实现一个计算器程序，具体代码如下：
#include <stdio.h>
#include <stdlib.h>
#define MAXOP 100 // max size of operand or operator
#define NUMBER '0' // signal that a number was found int getop(char []);
void push(double);
double pop(void);// reverse Polish calculator
int main()
{
int type;
double op2;
char s[MAXOP];
while ((type = getop(s)) != EOF) {
switch (type) {
case NUMBER:
push(atof(s));
break;
case '+':
push(pop() + pop());
break;
case '*':
push(pop() * pop());
break;
case '-':
op2 = pop();
push(pop() - op2);
break;
case '/':
op2 = pop();
if (op2 != 0.0)
push(pop() / op2);
else
printf("error: zero divisor\n");
break;
case '%':
op2 = pop();
if (op2 != 0.0)
push(fmod(pop(), op2));
else
printf("error: zero divisor\n");
break;
case '^':
op2 = pop();
push(pow(pop(), op2));
break;
case '\n':
printf("\t%.8g\n", pop());
break;
default:
printf("error: unknown command %s\n", s);
break;
}
}
return 0;
}

### 回答2：
算符优先分析是一种用于处理算术表达式的方法。使用C语言实现一个计算器，需要完成加、减、乘、除、幂、括号运算。为了实现这个功能，可以按照以下步骤进行设计：

1. 构建符号表：利用C语言的结构体定义运算符优先级表，记录所有运算符及其优先级。

2. 读入输入表达式：通过C语言的输入函数读入一个表达式字符串。

3. 构建操作符栈和操作数栈，以及一个操作符栈栈顶符号为#（用以标识栈的底部）。

4. 进行符号扫描：从左到右逐个扫描输入的符号串，根据算符优先级确定何时进行计算。

5. 进行算符优先分析：
a. 如果扫描到的符号是操作数，则将其压入操作数栈中。
b. 如果扫描到的符号是运算符，则根据运算符优先级判断如何进行计算：
i. 如果运算符优先级大于操作符栈栈顶符号的优先级，将运算符压入操作符栈。
ii. 如果运算符优先级小于或等于操作符栈栈顶符号的优先级，则从操作数栈中弹出两个操作数，并从操作符栈中弹出一个运算符进行计算，并将计算结果压入操作数栈。
6. 重复步骤5，直到扫描完成。

7. 最后，将操作数栈中剩下的操作数作为表达式的计算结果。若操作数栈为空，则表明表达式有误。

这样就实现了用C语言设计一个计算器，并可以判断给定任意符号串是否是正确的表达式，并给出计算结果。

代码如下：

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

struct operator {
    char symbol;
    int priority;
};

bool is_operator(char symbol) {
    if (symbol == '+' || symbol == '-' || symbol == '*' || symbol == '/' || symbol == '^' || symbol == '(' || symbol == ')') {
        return true;
    }
    return false;
}

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

int calculate(int operand1, int operand2, char operator) {
    switch (operator) {
        case '+':
            return operand1 + operand2;
        case '-':
            return operand1 - operand2;
        case '*':
            return operand1 * operand2;
        case '/':
            return operand1 / operand2;
        case '^':
            int result = 1;
            for(int i = 1; i <= operand2; i++){
                result *= operand1;
            }
            return result;
        default:
            break;
    }
    return 0;
}

int main() {
    struct operator operators[] = {
        {'+', 1},
        {'-', 1},
        {'*', 2},
        {'/', 2},
        {'^', 3},
        {'(', 0},
        {')', 0}
    };
    
    char expression[100];
    printf("请输入表达式：");
    scanf("%s", expression);
    
    int operand_stack[100];
    char operator_stack[100];
    int operand_top = -1;
    int operator_top = -1;
    operator_stack[++operator_top] = '#';
    
    int length = strlen(expression);
    bool is_valid = true;
    
    for (int i = 0; i < length; i++) {
        char symbol = expression[i];
        
        if (!is_operator(symbol)) {
            // 符号为操作数
            operand_stack[++operand_top] = symbol - '0';
        } else {
            // 符号为运算符
            if (operator_top > -1 && get_priority(symbol) <= get_priority(operator_stack[operator_top])) {
                // 当前运算符优先级小于或等于操作符栈栈顶符号的优先级，进行计算
                int operand2 = operand_stack[operand_top--];
                int operand1 = operand_stack[operand_top--];
                char operator = operator_stack[operator_top--];
                
                int result = calculate(operand1, operand2, operator);
                operand_stack[++operand_top] = result;
                --i;  // 重新处理计算结果
            } else {
                // 当前运算符优先级大于操作符栈栈顶符号的优先级，将运算符入栈
                operator_stack[++operator_top] = symbol;
            }
        }
    }
    
    while (operator_top > -1) {
        // 扫描结束，将剩下的运算符进行计算
        if (operand_top < 1) {
            is_valid = false;
            break;
        }
        
        int operand2 = operand_stack[operand_top--];
        int operand1 = operand_stack[operand_top--];
        char operator = operator_stack[operator_top--];
        
        int result = calculate(operand1, operand2, operator);
        operand_stack[++operand_top] = result;
    }
    
    if (operand_top == 0 && operator_top == -1 && is_valid) {
        printf("计算结果：%d\n", operand_stack[operand_top]);
    } else {
        printf("表达式无效\n");
    }
    
    return 0;
}

### 回答3：
在C语言中，可以使用算符优先分析法来设计一个计算器。首先，我们需要定义一个函数来判断一个字符是否是运算符。

int is_operator(char c) {
    if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^' || c == '(' || c == ')') {
        return 1;
    } else {
        return 0;
    }
}

接下来，我们定义一个函数来判断运算符的优先级。

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

然后，我们定义一个函数来计算两个操作数和一个运算符的值。

int perform_operation(int operand1, int operand2, char operator) {
    if (operator == '+') {
        return operand1 + operand2;
    } else if (operator == '-') {
        return operand1 - operand2;
    } else if (operator == '*') {
        return operand1 * operand2;
    } else if (operator == '/') {
        return operand1 / operand2;
    } else if (operator == '^') {
        int result = 1;
        for (int i = 0; i < operand2; i++) {
            result *= operand1;
        }
        return result;
    } else {
        return 0;
    }
}

最后，我们可以实现一个算符优先分析算法来计算表达式的值。

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

int is_operator(char c) {
    // 省略代码
}

int operator_precedence(char c) {
    // 省略代码
}

int perform_operation(int operand1, int operand2, char operator) {
    // 省略代码
}

int calculate(char expression[]) {
    int operands[100];
    char operators[100];
    int operand_index = 0;
    int operator_index = 0;
    
    for (int i = 0; i < strlen(expression); i++) {
        if (expression[i] == '(') {
            operators[operator_index] = expression[i];
            operator_index++;
        } else if (isdigit(expression[i])) {
            char operand_str[100];
            int j = 0;
            while (isdigit(expression[i])) {
                operand_str[j] = expression[i];
                i++;
                j++;
            }
            operand_str[j] = '\0';
            i--;
            operands[operand_index] = atoi(operand_str);
            operand_index++;
        } else if (expression[i] == ')') {
            while (operators[operator_index - 1] != '(') {
                int operand2 = operands[operand_index - 1];
                int operand1 = operands[operand_index - 2];
                char operator = operators[operator_index - 1];
                operand_index -= 2;
                operands[operand_index] = perform_operation(operand1, operand2, operator);
                operator_index--;
            }
            operator_index--;
        } else if (is_operator(expression[i])) {
            while (operator_index > 0 && operator_precedence(expression[i]) <= operator_precedence(operators[operator_index - 1])) {
                int operand2 = operands[operand_index - 1];
                int operand1 = operands[operand_index - 2];
                char operator = operators[operator_index - 1];
                operand_index -= 2;
                operands[operand_index] = perform_operation(operand1, operand2, operator);
                operator_index--;
            }
            operators[operator_index] = expression[i];
            operator_index++;
        }
    }
    
    while (operator_index > 0) {
        int operand2 = operands[operand_index - 1];
        int operand1 = operands[operand_index - 2];
        char operator = operators[operator_index - 1];
        operand_index -= 2;
        operands[operand_index] = perform_operation(operand1, operand2, operator);
        operator_index--;
    }
    
    return operands[0];
}

int main() {
    char expression[100];
    printf("请输入表达式：");
    scanf("%[^\n]", expression);
    
    if (calculate(expression)) {
        printf("表达式是正确的，计算结果为：%d\n", calculate(expression));
    } else {
        printf("表达式是错误的\n");
    }
    
    return 0;
}

以上就是使用算符优先分析方法设计的一个简单计算器的具体代码。用户可以输入任意符号串进行计算，程序会判断表达式的正确性，并给出计算结果。