C++实现eval函数功能（附带源码）

Katie。

于 2025-01-29 03:30:00 发布

阅读量765

点赞数 11

分类专栏： c、c++实战项目文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_61840987/article/details/145389521

版权

c、c++实战项目专栏收录该内容

510 篇文章

订阅专栏

C++实现eval函数功能：从思路到实现

1. 引言

在编程语言中，eval函数是一个非常有用的工具，它允许程序在运行时动态地执行字符串形式的代码。例如，在Python中，eval函数可以执行一个字符串表达式并返回结果。然而，C++作为一门静态类型语言，并没有内置的eval函数。本文将详细介绍如何在C++中实现一个类似eval的功能，能够解析并计算字符串形式的数学表达式。

2. 项目背景

C++是一门强大的系统编程语言，广泛应用于高性能计算、游戏开发、嵌入式系统等领域。然而，C++的标准库并没有提供直接执行字符串表达式的能力。为了实现这一功能，我们需要手动编写一个表达式解析器和求值器。

本项目的主要目标是实现一个C++程序，能够解析并计算包含基本数学运算（加、减、乘、除、括号等）的字符串表达式。通过这个项目，我们可以深入理解编译原理中的词法分析、语法分析和表达式求值等概念。

3. 实现思路

3.1 什么是eval函数？

eval函数通常用于动态执行代码。在解释型语言如Python、JavaScript中，eval函数可以直接执行字符串形式的代码。例如：

result = eval("3 + 5 * 2")  # 输出13

在C++中，由于语言的静态特性，我们无法直接执行字符串代码。因此，我们需要手动实现一个表达式解析器和求值器。

3.2 C++实现eval的挑战

在C++中实现eval功能的主要挑战包括：

词法分析：将输入的字符串分解成有意义的词法单元（tokens），如数字、运算符、括号等。
语法分析：根据词法单元构建语法树，确保表达式符合语法规则。
表达式求值：根据语法树计算表达式的值。

3.3 解决方案

为了克服这些挑战，我们可以将问题分解为以下几个步骤：

词法分析：将输入的字符串分解成一系列的词法单元（tokens）。
语法分析：使用递归下降法或调度场算法（Shunting Yard Algorithm）将词法单元转换为抽象语法树（AST）或逆波兰表达式（RPN）。
表达式求值：根据语法树或逆波兰表达式计算表达式的值。

4. 项目实现

4.1 词法分析

词法分析是将输入的字符串分解成一系列的词法单元（tokens）。例如，表达式 "3 + 5 * 2" 可以被分解为以下tokens：

[数字:3, 运算符:+, 数字:5, 运算符:*, 数字:2]

4.2 语法分析

语法分析是将词法单元转换为语法树或逆波兰表达式。我们可以使用递归下降法或调度场算法来实现这一步骤。

递归下降法：通过递归的方式解析表达式，构建语法树。
调度场算法：将中缀表达式转换为逆波兰表达式（RPN），便于后续求值。

4.3 表达式求值

表达式求值是根据语法树或逆波兰表达式计算表达式的值。对于逆波兰表达式，我们可以使用栈来轻松实现求值。

5. 代码实现

#include <iostream>
#include <string>
#include <vector>
#include <cctype>
#include <stack>
#include <unordered_map>
#include <stdexcept>

// 定义Token类型
enum class TokenType {
    Number,     // 数字
    Operator,   // 运算符
    LeftParen,  // 左括号
    RightParen, // 右括号
    End         // 结束标记
};

// 定义Token结构体，表示词法单元
struct Token {
    TokenType type;  // Token类型
    std::string value; // Token的值
};

// 词法分析器类
class Lexer {
public:
    Lexer(const std::string& input) : input(input), pos(0) {}

    // 将输入字符串分解为Token列表
    std::vector<Token> tokenize() {
        std::vector<Token> tokens;
        while (pos < input.size()) {
            char current = input[pos];
            if (std::isspace(current)) {
                pos++; // 跳过空格
            } else if (std::isdigit(current) || current == '.') {
                tokens.push_back(readNumber()); // 读取数字
            } else if (current == '+' || current == '-' || current == '*' || current == '/') {
                tokens.push_back({TokenType::Operator, std::string(1, current)}); // 读取运算符
                pos++;
            } else if (current == '(') {
                tokens.push_back({TokenType::LeftParen, "("}); // 读取左括号
                pos++;
            } else if (current == ')') {
                tokens.push_back({TokenType::RightParen, ")"}); // 读取右括号
                pos++;
            } else {
                throw std::runtime_error("Unknown character: " + std::string(1, current)); // 未知字符报错
            }
        }
        tokens.push_back({TokenType::End, ""}); // 添加结束标记
        return tokens;
    }

private:
    // 读取数字
    Token readNumber() {
        std::string number;
        while (pos < input.size() && (std::isdigit(input[pos]) || input[pos] == '.')) {
            number += input[pos++]; // 拼接数字字符
        }
        return {TokenType::Number, number}; // 返回数字Token
    }

    std::string input; // 输入字符串
    size_t pos;        // 当前解析位置
};

// 语法分析器类
class Parser {
public:
    Parser(const std::vector<Token>& tokens) : tokens(tokens), pos(0) {}

    // 解析表达式并返回计算结果
    double parse() {
        return parseExpression();
    }

private:
    // 解析加减法表达式
    double parseExpression() {
        double result = parseTerm(); // 解析第一个项
        while (pos < tokens.size()) {
            Token token = tokens[pos];
            if (token.type == TokenType::Operator && (token.value == "+" || token.value == "-")) {
                pos++;
                double term = parseTerm(); // 解析下一个项
                if (token.value == "+") {
                    result += term; // 加法
                } else {
                    result -= term; // 减法
                }
            } else {
                break; // 如果不是加减法运算符，退出循环
            }
        }
        return result;
    }

    // 解析乘除法表达式
    double parseTerm() {
        double result = parseFactor(); // 解析第一个因子
        while (pos < tokens.size()) {
            Token token = tokens[pos];
            if (token.type == TokenType::Operator && (token.value == "*" || token.value == "/")) {
                pos++;
                double factor = parseFactor(); // 解析下一个因子
                if (token.value == "*") {
                    result *= factor; // 乘法
                } else {
                    result /= factor; // 除法
                }
            } else {
                break; // 如果不是乘除法运算符，退出循环
            }
        }
        return result;
    }

    // 解析因子（数字或括号表达式）
    double parseFactor() {
        Token token = tokens[pos];
        if (token.type == TokenType::Number) {
            pos++;
            return std::stod(token.value); // 返回数字值
        } else if (token.type == TokenType::LeftParen) {
            pos++;
            double result = parseExpression(); // 解析括号内的表达式
            if (tokens[pos].type != TokenType::RightParen) {
                throw std::runtime_error("Expected right parenthesis"); // 缺少右括号报错
            }
            pos++;
            return result;
        } else {
            throw std::runtime_error("Unexpected token"); // 未知Token报错
        }
    }

    std::vector<Token> tokens; // Token列表
    size_t pos;                // 当前解析位置
};

// 表达式求值器类
class Evaluator {
public:
    Evaluator(const std::string& expression) : expression(expression) {}

    // 计算表达式的值
    double evaluate() {
        Lexer lexer(expression);
        std::vector<Token> tokens = lexer.tokenize(); // 词法分析
        Parser parser(tokens);
        return parser.parse(); // 语法分析并求值
    }

private:
    std::string expression; // 输入表达式
};

// 主函数
int main() {
    std::string input;
    std::cout << "Enter an expression: ";
    std::getline(std::cin, input); // 读取用户输入

    try {
        Evaluator evaluator(input);
        double result = evaluator.evaluate(); // 计算表达式
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl; // 捕获并输出错误
    }

    return 0;
}