c++编写一个完整的词法分析器

好的，以下是一个简单的 C++ 词法分析器的实现，可以解析基本的算术表达式：

#include <iostream>
#include <string>
#include <vector>
#include <cctype>

using namespace std;

// Token类，表示一个词法单元
class Token {
public:
    enum Type { NUMBER, PLUS, MINUS, MULTIPLY, DIVIDE, LPAREN, RPAREN, END };
    Type type;  // 单元类型
    int value;  // 如果是数字，存储其值

    Token(Type type, int value = 0) : type(type), value(value) {}
};

// 词法分析器类
class Lexer {
private:
    string text;   // 待分析的字符串
    size_t pos = 0; // 当前分析到的位置

public:
    Lexer(string text) : text(text) {}

    // 读取下一个字符并返回
    char curr_char() {
        if (pos >= text.size()) {
            return '\0';
        } else {
            return text[pos];
        }
    }

    // 将当前位置向后移动一个字符
    void next_char() {
        ++pos;
    }

    // 跳过空白字符
    void skip_whitespace() {
        while (isspace(curr_char())) {
            next_char();
        }
    }

    // 从当前位置开始解析一个数字
    int parse_number() {
        int res = 0;
        while (isdigit(curr_char())) {
            res = res * 10 + (curr_char() - '0');
            next_char();
        }
        return res;
    }

    // 解析下一个词法单元并返回
    Token get_next_token() {
        while (curr_char() != '\0') {
            if (isspace(curr_char())) {
                skip_whitespace();
                continue;
            } else if (isdigit(curr_char())) {
                return Token(Token::NUMBER, parse_number());
            } else if (curr_char() == '+') {
                next_char();
                return Token(Token::PLUS);
            } else if (curr_char() == '-') {
                next_char();
                return Token(Token::MINUS);
            } else if (curr_char() == '*') {
                next_char();
                return Token(Token::MULTIPLY);
            } else if (curr_char() == '/') {
                next_char();
                return Token(Token::DIVIDE);
            } else if (curr_char() == '(') {
                next_char();
                return Token(Token::LPAREN);
            } else if (curr_char() == ')') {
                next_char();
                return Token(Token::RPAREN);
            } else {
                throw runtime_error("invalid token");
            }
        }
        return Token(Token::END);
    }
};

// 解释器类
class Interpreter {
private:
    Lexer lexer;          // 词法分析器
    Token current_token;  // 当前的词法单元

public:
    Interpreter(Lexer lexer) : lexer(lexer) {}

    // 抛出语法错误
    void error() {
        throw runtime_error("syntax error");
    }

    // 匹配当前词法单元并获取下一个
    void eat(Token::Type type) {
        if (current_token.type == type) {
            current_token = lexer.get_next_token();
        } else {
            error();
        }
    }

    // 解析一个因子（数字或括号中的表达式）
    int factor() {
        if (current_token.type == Token::NUMBER) {
            int value = current_token.value;
            eat(Token::NUMBER);
            return value;
        } else if (current_token.type == Token::LPAREN) {
            eat(Token::LPAREN);
            int res = expr();
            eat(Token::RPAREN);
            return res;
        } else {
            error();
            return 0;
        }
    }

    // 解析一个乘法或除法表达式
    int term() {
        int res = factor();
        while (current_token.type == Token::MULTIPLY || current_token.type == Token::DIVIDE) {
            if (current_token.type == Token::MULTIPLY) {
                eat(Token::MULTIPLY);
                res *= factor();
            } else if (current_token.type == Token::DIVIDE) {
                eat(Token::DIVIDE);
                res /= factor();
            }
        }
        return res;
    }

    // 解析一个加法或减法表达式
    int expr() {
        int res = term();
        while (current_token.type == Token::PLUS || current_token.type == Token::MINUS) {
            if (current_token.type == Token::PLUS) {
                eat(Token::PLUS);
                res += term();
            } else if (current_token.type == Token::MINUS) {
                eat(Token::MINUS);
                res -= term();
            }
        }
        return res;
    }

    // 执行解释器
    int interpret() {
        current_token = lexer.get_next_token();
        return expr();
    }
};

int main() {
    while (true) {
        string text;
        cout << "calc> ";
        getline(cin, text);
        if (text.empty()) {
            break;
        }
        Lexer lexer(text);
        Interpreter interpreter(lexer);
        try {
            int result = interpreter.interpret();
            cout << result << endl;
        } catch (runtime_error& e) {
            cerr << e.what() << endl;
        }
    }
    return 0;
}

这个词法分析器可以解析基本的算术表达式，例如：

calc> 1 + 2 * 3 - 4 / 2
5