帮我用c++写一个代码实现以下要求，1) 完成表达式类; 2) 完成中缀转后缀函数，完成后缀表达式的求值函数; 3) 完成函数判断中缀表达式是否合法（仅需考虑括号是否匹配）

在 C++ 中，我们可以创建一个 `Expression` 类来表示中缀表达式，并实现相关的转换和验证功能。这里是一个简单的示例：

#include <iostream>
#include <stack>
#include <string>

// 用于存储操作符优先级的结构体
struct Operator {
    char op;
    int priority;
};

// Expression 类，包含中缀表达式字符串
class Expression {
private:
    std::string expression;

public:
    // 构造函数
    Expression(const std::string& exp) : expression(exp) {}

    // 检查中缀表达式是否合法
    bool isValid() {
        std::stack<char> parentheses;
        for (char c : expression) {
            if (c == '(')
                parentheses.push(c);
            else if (c == ')')
                if (parentheses.empty())
                    return false; // 未关闭的左括号
                else
                    parentheses.pop();
            else if (c == '+' || c == '-' || c == '*' || c == '/')
                continue; // 操作符不需要检查
            else
                return false; // 非法字符
        }
        return parentheses.empty(); // 确保所有括号都已关闭
    }

    // 中缀转后缀（逆波兰表达式）
    std::string infixToPostfix() {
        std::stack<Operator> ops;
        std::string postfix;
        for (char c : expression) {
            if (isdigit(c))
                postfix += c;
            else if (c == '(')
                ops.push({'.', 0}); // 临时存储左括号，优先级为0
            else if (c == ')')
                while (!ops.empty() && ops.top().op != '(')
                    postfix += ops.top().op, ops.pop();
            else { // 操作符
                while (!ops.empty() && ops.top().priority >= c - '0') // 比较优先级
                    postfix += ops.top().op, ops.pop();
                ops.push({c, static_cast<int>(c - '0')}); // 入栈当前操作符及其优先级
            }
        }
        while (!ops.empty())
            postfix += ops.top().op, ops.pop(); // 将剩余的操作符加入后缀表达式
        return postfix;
    }

    // 后缀表达式求值
    double evaluatePostfix(const std::string& postfix) {
        std::stack<double> numbers;
        for (char c : postfix) {
            if (isdigit(c))
                numbers.push(stod(std::string(1, c)));
            else {
                double right = numbers.top(); numbers.pop();
                double left = numbers.top(); numbers.pop();
                switch (c) {
                    case '+': numbers.push(left + right); break;
                    case '-': numbers.push(left - right); break;
                    case '*': numbers.push(left * right); break;
                    case '/': if (right != 0) numbers.push(left / right); else throw "Division by zero"; break;
                }
            }
        }
        return numbers.top();
    }
};

int main() {
    std::string expression = "3+5*(2-1)";
    Expression e(expression);

    if (e.isValid()) {
        std::cout << "Valid expression.\n";
        std::string postfix = e.infixToPostfix();
        double result = e.evaluatePostfix(postfix);
        std::cout << "Postfix form: " << postfix << "\n";
        std::cout << "Result: " << result << "\n";
    } else {
        std::cout << "Invalid expression.\n";
    }

    return 0;
}

这个代码首先定义了一个 `Expression` 类，包含了 `isValid`、`infixToPostfix` 和 `evaluatePostfix` 函数。`isValid` 方法检查表达式是否只包含合法的字符（数字和括号），`infixToPostfix` 转换为后缀表达式，而 `evaluatePostfix` 则计算后缀表达式的值。

在 `main` 函数中，我们测试了一个例子并展示了整个过程。如果输入的中缀表达式无效，程序会显示 "Invalid expression."。