exprtk完成数学表达式的检验

#include <QtCore/QCoreApplication>
#include<iostream>
#include <QDebug>
#include <cstdio>
#include <string>
#include "exprtk.hpp"
using namespace std;
double calc(const std::string& expression_string)
{
    exprtk::symbol_table<double> symbol_table;
    symbol_table.add_constants();
    //symbol_table.add_variable("x", 0.0);

    exprtk::expression<double> expression;
    expression.register_symbol_table(symbol_table);

    exprtk::parser<double> parser;
    parser.compile(expression_string, expression);

    double result = expression.value();

    return result;
}
bool validateExpression(const std::string& expressionString)
{
    typedef exprtk::symbol_table<double> symbol_table_t;
    typedef exprtk::expression<double> expression_t;
    typedef exprtk::parser<double> parser_t;

    symbol_table_t symbol_table;
    expression_t expression;
    parser_t parser;

    if (!parser.compile(expressionString, expression))
    {
       // std::cout << "Expression compilation failed!" << std::endl;
        return false;
    }

    return true;
}

void test(string expressionTest)
{

    if (validateExpression(expressionTest)) {
         
        std::cout << "表达式合法,结果是" << calc(expressionTest)<< std::endl;
    }
    else {
        std::cout << "表达式不合法" << std::endl;
    }
}
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    std::string expression1="2 + 3 * 4";
    std::string expression2 = "(5 > 3) && (2 < 4)";
    std::string expression3 = "2 + 3 * 4-7*9";//-49
    std::string expression4 = "2*2-1 + 3 * 4-7*9/3";//-6
  
    test(expression1);
    test(expression2);
    test(expression3);
    test(expression4);
   

    return a.exec();
}

给定一个 表达式字符串 'z ：= x - （3 * y）' 和三个变量 （x， y 和 z）， EXPRTK：：symbol_table 被实例化，变量被添加到其中。然后实例化 exprtk：：expression，并将符号表注册到表达式中 实例。最后，exprtk：:p arser 被实例化，其中表达式对象和 表达式的字符串形式被传递给名为 compile 的解析器方法。

如果编译过程成功，表达式实例现在将保存一个 AST，该 AST 可以 进一步用于评估原始表达式。否则将引发编译错误，并且 通过解析器的错误报告接口提供与错误相关的诊断。 示例中的表达式将使用变量 x 和 y 执行计算，然后继续将计算结果分配给变量 z。

template<typename T>
T evaluateExpression(const std::string& expression_string, std::map<std::string, T>& variables) {
    typedef exprtk::symbol_table<T> symbol_table_t;
    typedef exprtk::expression<T> expression_t;
    typedef exprtk::parser<T> parser_t;

    symbol_table_t symbol_table;
    expression_t expression;
    parser_t parser;

    // 添加变量到符号表
    for (auto& variable : variables) {
        symbol_table.add_variable(variable.first, variable.second);
    }

    expression.register_symbol_table(symbol_table);

    if (!parser.compile(expression_string, expression)) {
        std::cerr << "Compilation error.." << std::endl;
        // 返回一个默认值，或者抛出异常，表示计算错误
        return T();
    }
    else {
        // 计算表达式并返回结果
        return expression.value();
    }
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
     
    std::string expression_string = "z := x - (3 * y)";
    std::map<std::string, double> variables = { {"x", 123.456}, {"y", 98.98}, {"z", 0.0} };

    double result = evaluateExpression(expression_string, variables);
    std::cout << "Result is " << result << std::endl;

    return a.exec();
}