实现一个简单的计算器，输入一个算术表达式，其运算符包含圆括号、加、减、乘、除、求余等符号，输出该算术表达式的值。要求： （1）系统至少能实现加、减、乘、除、求余等运算； （2）利用栈的后进先出特性实现； 采用双栈（运算符栈和操作数栈）的方法计算表达式的值。

要实现一个简单的计算器，可以使用双栈数据结构，其中一个栈用于存储操作数，另一个栈用于存储运算符。这里是一个基本的C语言代码示例，实现了加、减、乘、除、求余以及处理圆括号的功能：

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

// 定义运算符优先级
enum Op {
    PLUS = 1,
    MINUS,
    TIMES,
    DIVIDE,
    MOD,
    LPAREN,
    RPAREN
};

bool isOperator(char op) {
    return op == '+' || op == '-' || op == '*' || op == '/' || op == '%';
}

double performOp(double a, double b, enum Op op) {
    switch (op) {
        case PLUS:
            return a + b;
        case MINUS:
            return a - b;
        case TIMES:
            return a * b;
        case DIVIDE:
            if (b != 0)
                return a / b;
            else
                printf("Error: Division by zero.\n");
            return 0; // 返回0表示错误，实际应用中可能抛出异常
        case MOD:
            return fmod(a, b);
        default:
            return a; // 如果是LPAREN或RPAREN，不执行任何操作
    }
}

void evaluateExpression(char* expression) {
    stack_t operands = {0};
    stack_t operators = {0};
    int i = 0;

    while (expression[i] != '\0') {
        if (isOperator(expression[i])) {
            while (!operators.is_empty() && hasHigherPriority(operators.peek(), expression[i])) {
                double b = operands.pop();
                double a = operands.pop();
                enum Op current_op = operators.pop();
                operands.push(performOp(a, b, current_op));
            }
            operators.push(expression[i++]);
        } else if (expression[i] == ' ') {
            i++; // 忽略空格
        } else if (expression[i] == '(') {
            operators.push(expression[i++]);
        } else if (expression[i] == ')') {
            while (!operators.is_empty() && operators.top() != LPAREN) {
                double b = operands.pop();
                double a = operands.pop();
                enum Op current_op = operators.pop();
                operands.push(performOp(a, b, current_op));
            }
            if (operators.top() != LPAREN) {
                printf("Error: Unmatched parentheses.\n");
                return;
            }
            operators.pop(); // 移除左括号
        } else {
            double num = atof(expression + i); // 将数字转换为double
            operands.push(num);
            i += strlen(expression + i); // 跳过数字字符
        }
    }

    while (!operators.is_empty()) {
        double b = operands.pop();
        double a = operands.pop();
        enum Op current_op = operators.pop();
        operands.push(performOp(a, b, current_op));
    }

    if (operands.size() != 1) {
        printf("Error: Invalid expression.\n");
        return;
    }
    printf("Result: %f\n", operands.top());
}

int main() {
    char expression[] = "5 + 7 * (3 - 2) / 4";
    evaluateExpression(expression);
    return 0;
}

// Stack structure and related functions (not shown for brevity)
typedef struct stack_t {
    size_t size;
    double* data;
} stack_t;

stack_t createStack(size_t capacity) {
    ...
}

void push(stack_t* stack, double value) {
    ...
}

double pop(stack_t* stack) {
    ...
}

bool is_empty(const stack_t* stack) {
    ...
}

size_t size(const stack_t* stack) {
    ...
}

bool hasHigherPriority(enum Op op1, enum Op op2) {
    // 实现运算符优先级比较逻辑
    ...
}

这段代码首先定义了一个`evaluateExpression`函数，它遍历给定的表达式，根据遇到的操作符和运算数对两个栈进行处理。注意，这个示例没有提供完整的栈结构和相关的辅助函数，如`createStack`, `push`, `pop`, `is_empty`, 和 `hasHigherPriority`。这些都需要你自己实现。

运行上述程序时，用`main`中的`evaluateExpression`函数，传入算术表达式字符串。如果表达式正确，它将计算并打印结果；否则，显示相应的错误消息。