要求可以解决带有（、）的运算

好的，实现带有括号的四则混合运算计算器需要使用到表达式求值的算法。具体实现思路如下：

1. 将中缀表达式转换为后缀表达式。
2. 对后缀表达式进行求值。

中缀表达式转后缀表达式的方法可以使用栈来实现。具体实现步骤如下：

1. 从左到右遍历中缀表达式中的每个数字和符号。
2. 如果当前字符是数字，直接输出。
3. 如果当前字符是左括号，将其压入栈中。
4. 如果当前字符是右括号，则依次弹出栈顶元素并输出，直到遇到左括号为止。
5. 如果当前字符是运算符，比较其与栈顶元素的优先级，如果栈顶元素优先级高，则弹出栈顶元素并输出，然后将当前符号压入栈中。否则，直接将当前符号压入栈中。
6. 重复步骤1-5，直到遍历完整个中缀表达式。
7. 如果栈中还有元素，依次弹出并输出。

下面是一个带括号的四则混合运算计算器的实现示例：

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

#define MAX_SIZE 100

typedef struct {
    char data[MAX_SIZE];
    int top;
} 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, char c) {
    if(isFull(s)) {
        printf("栈已满，不能再添加元素！");
        exit(1);
    }
    s->top++;
    s->data[s->top] = c;
}

char pop(Stack *s) {
    if(isEmpty(s)) {
        printf("栈已空，不能再删除元素！");
        exit(1);
    }
    char c = s->data[s->top];
    s->top--;
    return c;
}

char peek(Stack *s) {
    if(isEmpty(s)) {
        printf("栈已空，不能再查看栈顶元素！");
        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 getPriority(char c) {
    switch(c) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

void infixToPostfix(char *infix, char *postfix) {
    Stack s;
    initStack(&s);
    int i, j;
    char c;
    for(i = 0, j = 0; infix[i] != '\0'; i++) {
        c = infix[i];
        if(isDigit(c)) {
            postfix[j++] = c;
        } else if(c == '(') {
            push(&s, c);
        } else if(c == ')') {
            while(!isEmpty(&s) && peek(&s) != '(') {
                postfix[j++] = pop(&s);
            }
            if(isEmpty(&s)) {
                printf("括号不匹配！");
                exit(1);
            }
            pop(&s);
        } else if(isOperator(c)) {
            while(!isEmpty(&s) && getPriority(peek(&s)) >= getPriority(c)) {
                postfix[j++] = pop(&s);
            }
            push(&s, c);
        } else {
            printf("无效的表达式！");
            exit(1);
        }
    }
    while(!isEmpty(&s)) {
        c = pop(&s);
        if(c == '(') {
            printf("括号不匹配！");
            exit(1);
        }
        postfix[j++] = c;
    }
    postfix[j] = '\0';
}

float evaluate(char *postfix) {
    Stack s;
    initStack(&s);
    int i;
    float num1, num2, result;
    char c;
    for(i = 0; postfix[i] != '\0'; i++) {
        c = postfix[i];
        if(isDigit(c)) {
            push(&s, c - '0');
        } else if(isOperator(c)) {
            num2 = pop(&s);
            num1 = pop(&s);
            switch(c) {
                case '+':
                    result = num1 + num2;
                    break;
                case '-':
                    result = num1 - num2;
                    break;
                case '*':
                    result = num1 * num2;
                    break;
                case '/':
                    if(num2 == 0) {
                        printf("除数不能为0！");
                        exit(1);
                    }
                    result = num1 / num2;
                    break;
            }
            push(&s, result);
        } else {
            printf("无效的表达式！");
            exit(1);
        }
    }
    result = pop(&s);
    if(!isEmpty(&s)) {
        printf("表达式有误！");
        exit(1);
    }
    return result;
}

int main() {
    char infix[MAX_SIZE], postfix[MAX_SIZE];
    printf("请输入表达式：");
    scanf("%s", infix);
    infixToPostfix(infix, postfix);
    printf("后缀表达式：%s\n", postfix);
    float result = evaluate(postfix);
    printf("计算结果：%.2f\n", result);
    return 0;
}

该计算器可以处理带有括号的四则混合运算，用户输入表达式后，程序会将中缀表达式转换为后缀表达式，然后对后缀表达式进行求值，并输出结果。需要注意的是，如果表达式不合法，程序会输出错误信息并退出。