字符串表达式计算(Win32, C++)

置顶 已于 2024-03-01 21:57:58 修改
阅读量424 收藏 5
点赞数 11
分类专栏： Windows C++ Win32 文章标签： C++ Win32 二叉树
于 2024-01-18 13:27:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flame_Cyclone/article/details/135671953
版权
Win32 同时被 3 个专栏收录
58 篇文章 1 订阅
订阅专栏
C++
48 篇文章 0 订阅
订阅专栏
Windows
27 篇文章 0 订阅
订阅专栏

简单表达式计算实用类

支持的运算如表所示

运算符号释义例子
+加法1024+512
-减法1024-512
*乘法1024*1024
/除法1024/128
^平方1024^2
%取模(求余数)10%3
(优先级左括号(1024+512)*8
)优先级右括号(1024+512)*8

表达式示例:

表达式有效性备注
2+(2-7)*2*(8-2)/2有效 
1024^3有效1024的3次方
2(5+15)有效等同于2*(5+15)
2(5+15)+有效等同于2(5+15)+0
2(5+15)*有效等同于2(5+15)*1
+10--10有效等同于10-(-10)
-10++10有效等同于(-10)+10
2*()无效不允许括号内为空
2*(3+5无效缺失右括号
2++无效缺失操作数
2--无效缺失操作数

 

CCalculateUtils.h

#pragma once
#include <wtypesbase.h>
#include <tchar.h>
#include <vector>
#include <string>

#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif

class BTreeNode
{
public:
    BTreeNode()
        :
        m_leftChild(nullptr),
        m_rightChild(nullptr)
    {

    }

    ~BTreeNode()
    {
        Delete(m_leftChild);
        Delete(m_rightChild);
    }

    void Delete(BTreeNode* pNode)
    {
        if (nullptr != pNode)
        {
            Delete(pNode->m_leftChild);
            pNode->m_leftChild = nullptr;
            Delete(pNode->m_rightChild);
            pNode->m_rightChild = nullptr;
            delete pNode;
        }
    }

public:
    BTreeNode* m_leftChild;
    BTreeNode* m_rightChild;
    _tstring m_strValue;
};

class CCalculateUtils
{
public:

    //
    // @brief: 计算字符串算术表达式的结果
    // @param: strExp               表达式, 如: "(2+3)*8-67/2*(4-3)+5"
    // @param: lfResult             计算结果
    // @ret: bool                   操作成功与否
    static bool CCalculate(const _tstring& strExp, double& lfResult);

private:

    //
    // @brief: 获取分解后的表达式元素
    // @param: lpExpBegin           表达式起始位置
    // @param: lpExpEnd             表达式结束位置
    // @param: outExp               分解后的表达式元素序列
    // @ret: bool                   操作成功与否
    static bool GetExpressionElements(LPCTSTR lpExpBegin, LPCTSTR lpExpEnd, std::vector<_tstring>& outExp);

    //
    // @brief: 构建表达式二叉树
    // @param: outExp               表达式元素序列
    // @ret: BTreeNode*             表达式二叉树根结点
    static BTreeNode* BuildBinaryTree(std::vector<_tstring>& outExp);

    //
    // @brief: 计算表达式二叉树
    // @param: pNode                表达式二叉树根结点
    // @ret: double                 计算结果
    static double CalcBinaryTree(const BTreeNode* pNode);

    //
    // @brief: 检查字符串是否为数字
    // @param: strItem              字符串
    // @ret: bool                   是否为数字
    static bool IsNumber(const _tstring& strItem);

    //
    // @brief: 检查字符串是否为运算符
    // @param: strItem              字符串
    // @ret: bool                   是否为运算符
    static bool IsOperator(const _tstring& strItem);

    //
    // @brief: 检查字符是否为运算符
    // @param: ch                   字符
    // @ret: bool                   是否为运算符
    static bool IsOperator(TCHAR ch);

    //
    // @brief: 比较运算符优先级
    // @param: strLeft              运算符1
    // @param: strRight             运算符2
    // @ret: int                    0: 优先级相等, >0: strLeft 优先级高于 strRight, <0: strLeft 优先级低于 strRight
    static int CompareOperator(const _tstring& strLeft, const _tstring& strRight);
};

CCalculateUtils.cpp

#include "CCalculateUtils.h"
#include <stack>
#include <map>
#include <queue>
#include <ctgmath>

//运算符优先级
std::map<_tstring, int> g_operatorLevel =
{
    {_T("^"), 2},
    {_T("*"), 1},
    {_T("/"), 1},
    {_T("%"), 1},
    {_T("+"), 0},
    {_T("-"), 0}
};

int CCalculateUtils::CompareOperator(const _tstring& strLeft, const _tstring& strRight)
{
    return g_operatorLevel.find(strLeft)->second - g_operatorLevel.find(strRight)->second;
}

bool CCalculateUtils::IsNumber(const _tstring& strItem)
{
    LPCTSTR lpBegin = strItem.c_str();
    LPCTSTR lpEnd = strItem.c_str();

    if (_istdigit(*lpBegin))
    {
        return true;
    }

    (void)_tcstod(lpBegin, (LPTSTR*)&lpEnd);
    if (lpBegin != lpEnd)
    {
        return true;
    }

    return false;
}

bool CCalculateUtils::IsOperator(TCHAR ch)
{
    if (_T('+') == ch ||
        _T('-') == ch ||
        _T('*') == ch ||
        _T('/') == ch ||
        _T('%') == ch ||
        _T('^') == ch
        )
    {
        return true;
    }

    return false;
}

bool CCalculateUtils::IsOperator(const _tstring& strItem)
{
    if (_T("+") == strItem ||
        _T("-") == strItem ||
        _T("*") == strItem ||
        _T("/") == strItem ||
        _T("%") == strItem ||
        _T("^") == strItem
        )
    {
        return true;
    }

    return false;
}

BTreeNode* CCalculateUtils::BuildBinaryTree(std::vector<_tstring>& outExp)
{
    std::stack<_tstring> opStack;
    std::queue<_tstring> reversePolish;
    bool bSuccess = true;

    for (const auto& item : outExp)
    {
        if (IsNumber(item))
        {
            reversePolish.push(item);
        }
        else if (
            _T("+") == item ||
            _T("-") == item ||
            _T("*") == item ||
            _T("/") == item ||
            _T("%") == item ||
            _T("^") == item ||
            _T("(") == item ||
            _T(")") == item
            )
        {
            _tstring strOperate = item;

            if (_T("(") == item)
            {
                opStack.push(item);
            }
            else if (_T(")") == item)
            {
                while (!opStack.empty())
                {
                    _tstring strOperateTop = opStack.top();
                    opStack.pop();
                    if (_T("(") == strOperateTop)
                    {
                        break;
                    }
                    else
                    {
                        reversePolish.push(strOperateTop);
                    }
                }
            }
            else
            {
                while (!opStack.empty())
                {
                    _tstring strTopOperate = opStack.top();
                    if (_T("(") == strTopOperate)
                    {
                        opStack.push(strOperate);
                        break;
                    }
                    else if (CompareOperator(strTopOperate, strOperate) >= 0)
                    {
                        reversePolish.push(strTopOperate);
                        opStack.pop();
                    }
                    else if (CompareOperator(strTopOperate, strOperate) < 0)
                    {
                        opStack.push(strOperate);
                        break;
                    }
                }

                if (opStack.empty())
                {
                    opStack.push(strOperate);
                }
            }
        }
        else
        {
            return false;
        }
    }

    //剩下的操作符入队
    while (!opStack.empty())
    {
        _tstring strTopOperate = opStack.top();
        reversePolish.push(strTopOperate);
        opStack.pop();
    }

    //将后缀表达式转化成二叉树
    std::stack<BTreeNode*> nodeStack;
    while (!reversePolish.empty())
    {
        _tstring strTopOperate = reversePolish.front();
        BTreeNode* pNode = new (std::nothrow) BTreeNode();
        if (nullptr == pNode)
        {
            bSuccess = false;
            break;
        }

        pNode->m_strValue = strTopOperate;

        if (IsNumber(strTopOperate))
        {
            nodeStack.push(pNode);
        }
        else
        {
            if (nodeStack.size() < 2)
            {
                bSuccess = false;
                break;
            }

            pNode->m_rightChild = nodeStack.top();
            nodeStack.pop();
            pNode->m_leftChild = nodeStack.top();
            nodeStack.pop();
            nodeStack.push(pNode);
        }
        reversePolish.pop();
    }

    if (nodeStack.empty())
    {
        return nullptr;
    }

    if (!bSuccess)
    {
        BTreeNode* pNode = nodeStack.top();
        delete pNode;
        pNode = nullptr;
        return nullptr;
    }

    return nodeStack.top();
}

bool CCalculateUtils::GetExpressionElements(LPCTSTR lpExpBegin, LPCTSTR lpExpEnd, std::vector<_tstring>& outExp)
{
    LPCTSTR lpBegin = lpExpBegin;

    //拆分算式元素
    std::vector<_tstring> vectorExpression;
    while (lpBegin < lpExpEnd)
    {
        //是运算符
        if (IsOperator(*lpBegin))
        {
            bool bLastOperator = false;
            bool bLastNumber = false;
            bool bNumber = IsNumber(lpBegin);
            if (!vectorExpression.empty() && IsOperator(vectorExpression.back()))
            {
                bLastOperator = true;
            }

            if (!vectorExpression.empty() && IsNumber(vectorExpression.back()))
            {
                bLastNumber = true;
            }

            //当前元素可以转为数字
            if (bNumber)
            {
                //最近元素是运算符或者表达式容器为空, 则当作操作数处理
                if (bLastOperator || vectorExpression.empty())
                {
                    LPCTSTR lpTemp = lpBegin;
                    (void)_tcstod(lpBegin, (LPTSTR*)&lpTemp);
                    _tstring strExp = lpBegin;
                    strExp.resize(lpTemp - lpBegin);
                    vectorExpression.push_back(strExp);
                    lpBegin = lpTemp;
                }
                //否则仅当作运算符处理
                else
                {
                    _tstring strExp = lpBegin;
                    strExp.resize(1);
                    vectorExpression.push_back(strExp);
                    lpBegin++;
                }
            }
            //当前元素是运算符
            else
            {
                //最近元素是数字或者表达式元素不为空, 则当作运算符处理
                if (bLastNumber || !vectorExpression.empty())
                {
                    _tstring strExp = lpBegin;
                    strExp.resize(1);
                    vectorExpression.push_back(strExp);
                    lpBegin++;
                }
                //其他情况认为不合法
                else
                {
                    return false;
                }
            }
        }
        //遇到操作数
        else if (IsNumber(lpBegin))
        {
            //遇到右括号与数字挨着, 则添加乘法运算符
            if (!vectorExpression.empty() && _T(")") == vectorExpression.back())
            {
                vectorExpression.push_back(_T("*"));
            }

            LPCTSTR lpTemp = lpBegin;
            (void)_tcstod(lpBegin, (LPTSTR*)&lpTemp);
            _tstring strExp = lpBegin;
            strExp.resize(lpTemp - lpBegin);
            vectorExpression.push_back(strExp);
            lpBegin = lpTemp;
        }
        //遇到括号优先级
        else if (_T('(') == *lpBegin)
        {
            LPCTSTR lpTemp = lpBegin + 1;
            int nDeep = 1;

            while (lpTemp < lpExpEnd)
            {
                if (_T('(') == *lpTemp) nDeep++;
                if (_T(')') == *lpTemp) nDeep--;
                if (0 == nDeep) break;
                lpTemp++;
            }

            //不允许括号不匹配
            if (0 != nDeep)
            {
                return false;
            }

            //不允许空括号()
            if (1 == (lpTemp - lpBegin))
            {
                return false;
            }

            //获取子表达式元素
            std::vector<_tstring> subExp;
            if (!GetExpressionElements(lpBegin + 1, lpTemp, subExp))
            {
                return false;
            }

            //遇到数字与左括号挨着, 则添加乘法运算符
            if (!vectorExpression.empty() && IsNumber(vectorExpression.back()))
            {
                vectorExpression.push_back(_T("*"));
            }

            vectorExpression.push_back(_T("("));
            for (const auto& item : subExp)
            {
                vectorExpression.push_back(item);
            }
            vectorExpression.push_back(_T(")"));

            lpBegin = lpTemp + 1;
        }
        else
        {
            return false;
        }
    }

    if (!vectorExpression.empty())
    {
        //末尾元素是运算符, 但是没有操作数, 则补全一下
        _tstring strOperator = vectorExpression.back();
        if (_T("*") == strOperator || _T("/") == strOperator)
        {
            vectorExpression.push_back(_T("1"));
        }
        else if (_T("+") == strOperator || _T("-") == strOperator)
        {
            vectorExpression.push_back(_T("0"));
        }
        else if (_T("^") == strOperator)
        {
            vectorExpression.push_back(_T("2"));
        }
    }

    outExp = vectorExpression;
    return true;
}

bool CCalculateUtils::CCalculate(const _tstring& strExp, double& lfResult)
{
    //去除空格
    _tstring strDest = strExp;
    _tstring strFind = _T(" ");
    size_t nFind = 0;

    //查找去除空格
    while (_tstring::npos != (nFind = strDest.find(strFind)))
    {
        strDest.replace(nFind, strFind.size(), _T(""));
    };

    if (strDest.empty())
    {
        return false;
    }

    //获取表达式元素
    LPCTSTR lpBegin = strDest.c_str();
    LPCTSTR lpEnd = lpBegin + strDest.size();
    std::vector<_tstring> outExp;
    if (!GetExpressionElements(strDest.c_str(), lpEnd, outExp))
    {
        return false;
    }

    //构建计算二叉树
    BTreeNode* pCalcTree = BuildBinaryTree(outExp);
    if (pCalcTree)
    {
        //计算结果
        lfResult = CalcBinaryTree(pCalcTree);
        delete pCalcTree;
        pCalcTree = nullptr;
    }

    return true;
}

double CCalculateUtils::CalcBinaryTree(const BTreeNode* pNode)
{
    double lfLeftt = 0.0f;
    double lfRight = 0.0f;

    //左右子结点为空, 则返回数字
    if (nullptr == pNode->m_leftChild && nullptr == pNode->m_rightChild)
    {
        return _tcstod(pNode->m_strValue.c_str(), nullptr);
    }

    //计算左结点结果
    if (nullptr != pNode->m_leftChild)
    {
        lfLeftt = CalcBinaryTree(pNode->m_leftChild);
    }

    //计算右结点结果
    if (nullptr != pNode->m_rightChild)
    {
        lfRight = CalcBinaryTree(pNode->m_rightChild);
    }

    if (_T("+") == pNode->m_strValue)
    {
        lfLeftt = lfLeftt + lfRight;
    }

    if (_T("-") == pNode->m_strValue)
    {
        lfLeftt = lfLeftt - lfRight;
    }

    if (_T("*") == pNode->m_strValue)
    {
        lfLeftt = lfLeftt * lfRight;
    }

    if (_T("/") == pNode->m_strValue)
    {
        lfLeftt = lfLeftt / lfRight;
    }

    if (_T("%") == pNode->m_strValue)
    {
        if (lfLeftt * lfRight < 0)
        {
            double value = ::floor(lfLeftt / lfRight);
            lfLeftt = lfLeftt - (value * lfRight);
        }
        else
        {
            lfLeftt = ::fmod(lfLeftt, lfRight);
        }
    }

    if (_T("^") == pNode->m_strValue)
    {
        lfLeftt = ::pow(lfLeftt, lfRight);
    }

    return lfLeftt;
}

main.cpp

#include <iostream>
#include <vector>
#include <map>
#include <stdarg.h>
#include <tchar.h>
#include <windows.h>
#include <thread>
#include <strsafe.h>
#include "Win32Utils/CFileSplitUtils.h"
#include "Win32Utils/CPathUtils.h"
#include "Win32Utils/CTimeUtils.h"
#include "Win32Utils/CWaitableTimer.h"
#include "Win32Utils/CStrUtils.h"
#include "Win32Utils/CCalculateUtils.h"

int _tmain(int argc, LPCTSTR argv[])
{
    setlocale(LC_ALL, "");


    uint64_t ullBegin = CTimeUtils::GetCurrentTickCount();

    double lfValue1 = 0.0f;
    double lfValue2 = 0.0f;

    LPCTSTR ExpAry[] = {
        _T("2+(2-7)*2*(8-2)/2"),
        _T("1024^3"),
        _T("-512-512"),
        _T("2(3)5/2"),
        _T("2(3)5/2()"),
        _T("2(3)5/2("),
    };

    for (const auto& item : ExpAry)
    {
        _tprintf(_T("%s"), item);
        if (CCalculateUtils::CCalculate(item, lfValue1))
        {
            _tprintf(_T(" = %lf\n"), lfValue1);
        }
        else
        {
            _tprintf(_T(" = error!\n"));
        }
    }

    uint64_t ullEnd = CTimeUtils::GetCurrentTickCount();
    _tprintf(_T("cost time: %lldms\n"), ullEnd - ullBegin);

    return 0;
}

运行测试:

3fc66016e06f4ac5b8a90e3dadaa820e.png

 

 

 

Flame_Cyclone
关注
  • 11
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编码技巧 --- 如何实现字符串运算表达式的计算
2301_78834737的博客
07-13 295
刚开始拿到这个需求还是有点头疼的，想了很久的方案，突然想到之前看数据结构的书的时候，提到过栈在表达式求值中的应用，翻书看了一下，还是被这个实现方案惊艳到了，所以，还是需要多读多看多思考，才能在面对各种需求游刃有余，加油~
字符串算术运算
qq_45428582的博客
08-02 281
题目：k * [codedString] = k个codeString相加。其中k位正整数。 样例： “3*[a2*[c]]” 输出：“accaccacc” 思路：看到括号匹配首先用栈。再对可能遇到的情况进行分类。 function computeString(str) { // write code here // 准备两个栈，一个数字栈，一个字符栈 let stack = [], numStack = [], res = '';
C++算法之字符串
yohnyang的博客
09-18 708
字符串 1.字符串比较 题目一：判断两个字符串包含的字符是否完全相同 我们可以利用哈希表或者数组统计两个数组中每个数字出现的频次，若频次相同，则说明它们包含的字符完全相同。 bool isAnagram(string s,string t) { if(s.length() != t.length()) { return false; } vector<int>counts(26,0); for(int i=0;i<s.length(
【java计算字符串算式】
zcllgf的博客
02-18 938
java计算字符串算式，含括号
java解析并计算字符串算式
日日留心的技术专栏
09-01 9777
解析并计算，字符串形式的加减乘除算式，我亲测可行的，有一下两种方法： 1.直接通过Java代码，采用递归，手动解析计算： 参考如下连接：https://blog.csdn.net/qq_37969433/article/details/81174046 核心代码也列在下面： /** * 判断表达式是不是只有一个数字 * * @param str 原值 ...
VC++程序: 将字符串转换成公式并计算结果
10-23
int Calculate(string formula) 函数功能：输入一个字符串公式string formula，允许四则混合运算，然后输入公式中对应变量的取值，最后返回int类型计算结果。 变量的格式：必须由1位字母加1位数字组成，如a1、b2等。 如输入字符串 “(a1+b2)/(-100)”，以及a1=100,b2=300,得到结果-4。遇到小数则向下取整。 公式的格式： 1、只包含变量、常数、四则符号、小括号四种符号，不支持大括号和中括号 2、允许正数前加正号，如+100 3、不允许空括号，如 “8*（ ）” 4、允许负数，但负数必须加括号，如 "5/（-1）"。当负数在公式开头时，可不加括号， 如 "-a1+90"和“+a1+90” 都是对的 5、允许纯常数公式，如 “5*（-9）” 6、允许用户输入多余的空格,但空格不能造成公式错误， 如公式 “（1 08+a2)/a 3” 是错的，(- 7)和(- n5)是错的，去掉空格就对了。
Visual C++2010开发权威指南（共三部分）.part1.rar
11-12
5.21.3 在日期和时间选择器控件中使用自定义格式字符串 254 5.21.4 在日期和时间选择器控件中使用回调字段 254 5.21.5 处理日期和时间选择器控件中的通知消息 256 5.22 Visual C++ 2010 Month Canlendar控件简介与...
字符串计算公式计算
08-18
java 将字符串公式转直接可以进行计算得出结果。
C++语言实现：输入表达式字符串,求值
12-23
大二时的上机作业，验收通过，内含详细注释以及实验报告文档： 输入表达式字符串，以“=”表示结束， 计算并输出表达式值。 操作数可以是整数或实数，操作符有 “+”、“-”、“*”、“/”、“^”（乘方）和 “sin( )”（正弦）、“cos( )”（余弦）、“log( )（对数）、“ln( )”（自然对数）等函数。
实现计算算式字符串的2种方式(方式2)
qzyf1992的专栏
05-24 719
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data; namespace ConsoleApplication2 { class Program { static bool flag = true;
计算字符串的长度
m0_71403998的博客
08-13 3195
这时候只是函数内部的内容变动，主函数不变。时，可采用递归的方式，具体看下面的代码。以上就是计算一个字符串长度的三种方法了。第三种方式：指针-指针。运行结果还是依旧是7。
字符的计算
Sunshine_Qinger的博客
05-04 1099
#include <stdio.h> int main(int argc, const char * argv[]) { char c='A'; c++; printf("%c\n",c); int b='Z'-'A'; printf("%d\n",b); return 0; }
c语言字符串表达式计算,表达式计算（C语言版）
weixin_29802461的博客
05-17 1479
#include"stdlib.h"typedef double DataType; /*数据存放类型*/typedef int OpType; /*运算符存放类型*/char *code = "+-*/()#"; /*运算符串*/char priority[7][7] = {'>','>','','>','>','>','','>','...
用C语言实现字符串转表达式并计算结果
pirateT的博客
12-21 2873
用C语言实现字符串转表达式，支持小数 整数 科学计数法 ,运算符支持+ - * / 幂（^）。
cryptography-0.9-cp34-none-win32.whl
最新发布
06-18
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
python 包含数学符号的字符串表达式计算
06-02
如果要计算包含数学符号的字符串表达式，可以使用第三方库SymPy的parse_expr函数将字符串表达式转换为符号表达式，然后再进行计算。以下是一个例子，演示如何使用SymPy计算包含数学符号的字符串表达式： ```python import sympy # 定义字符串表达式 expr_str = 'x**2 + y**2' # 将字符串表达式转换为符号表达式 expr = sympy.parse_expr(expr_str) # 定义符号变量 x = sympy.Symbol('x') y = sympy.Symbol('y') # 计算表达式的值 result = expr.subs(x, 3).subs(y, 4) print(result) # 输出 25 ``` 在上面的例子中，我们先定义了字符串表达式expr_str，包含了x和y的平方和。然后我们使用parse_expr函数，将字符串表达式转换为符号表达式。接着我们定义了符号变量x和y，使用subs方法，将x和y分别替换成3和4，计算出了表达式的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值