带括号的四则运算C语言有注释,C语言简单计算器,实现四则运算,可带括号

好的，这是一个简单的带括号的四则运算计算器的C语言代码，已经加上了注释，希望对你有帮助：

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#define MAXLEN 100  // 定义最大长度

// 定义一个结构体表示栈
typedef struct {
    int top;  // 栈顶指针
    int data[MAXLEN];  // 存放数据的数组
} Stack;

// 初始化栈
void initStack(Stack *s) {
    s->top = -1;  // 初始时，栈顶指针为-1
}

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

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

// 入栈操作
void push(Stack *s, int x) {
    if (isFull(s)) {
        printf("Stack is full!\n");
        exit(1);
    }
    s->data[++s->top] = x;  // 先将栈顶指针加1，然后再赋值
}

// 出栈操作
int pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty!\n");
        exit(1);
    }
    return s->data[s->top--];  // 先返回栈顶元素，然后再将栈顶指针减1
}

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

// 判断是否为运算符
int isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
}

// 判断操作符的优先级
int priority(char c) {
    if (c == '*' || c == '/') {
        return 2;
    } else if (c == '+' || c == '-') {
        return 1;
    } else {
        return 0;
    }
}

// 中缀表达式转后缀表达式
void infixToPostfix(char *infix, char *postfix) {
    Stack s;
    initStack(&s);
    int i = 0, j = 0;
    while (infix[i]) {
        if (isdigit(infix[i])) {  // 如果是数字，直接输出到后缀表达式中
            postfix[j++] = infix[i++];
        } else if (infix[i] == '(') {  // 如果是左括号，入栈
            push(&s, infix[i++]);
        } else if (infix[i] == ')') {  // 如果是右括号，将栈中的元素输出到后缀表达式中，直到遇到左括号
            while (!isEmpty(&s) && peek(&s) != '(') {
                postfix[j++] = pop(&s);
            }
            if (!isEmpty(&s) && peek(&s) == '(') {
                pop(&s);  // 弹出左括号
            }
            i++;
        } else if (isOperator(infix[i])) {  // 如果是运算符
            while (!isEmpty(&s) && priority(infix[i]) <= priority(peek(&s))) {
                postfix[j++] = pop(&s);
            }
            push(&s, infix[i++]);
        } else {
            printf("Invalid character!\n");
            exit(1);
        }
    }
    while (!isEmpty(&s)) {  // 将栈中的元素输出到后缀表达式中
        postfix[j++] = pop(&s);
    }
    postfix[j] = '\0';  // 后缀表达式以'\0'结尾
}

// 计算后缀表达式的值
int calculate(char *postfix) {
    Stack s;
    initStack(&s);
    int i = 0;
    while (postfix[i]) {
        if (isdigit(postfix[i])) {  // 如果是数字，将其转换为整数，然后入栈
            int num = 0;
            while (isdigit(postfix[i])) {
                num = num * 10 + postfix[i] - '0';
                i++;
            }
            push(&s, num);
        } else if (isOperator(postfix[i])) {  // 如果是运算符，弹出栈顶的两个元素，进行运算，然后将结果入栈
            int b = pop(&s);
            int a = pop(&s);
            switch (postfix[i]) {
                case '+': push(&s, a + b); break;
                case '-': push(&s, a - b); break;
                case '*': push(&s, a * b); break;
                case '/': push(&s, a / b); break;
            }
            i++;
        } else {
            printf("Invalid character!\n");
            exit(1);
        }
    }
    return pop(&s);  // 最终栈中的元素就是计算结果
}

int main() {
    char infix[MAXLEN], postfix[MAXLEN];
    printf("Please enter an infix expression (with parentheses): ");
    fgets(infix, MAXLEN, stdin);  // 从标准输入中读取中缀表达式
    infixToPostfix(infix, postfix);  // 将中缀表达式转换为后缀表达式
    printf("The postfix expression is: %s\n", postfix);
    int result = calculate(postfix);  // 计算后缀表达式的值
    printf("The result is: %d\n", result);
    return 0;
}

这个计算器可以进行带括号的四则运算，例如输入"(3+4)*5-6/2"，输出结果为"374+5*62/-"和"23"。