C++实现简单计算器(字符串替换)

最新推荐文章于 2024-07-21 11:20:00 发布
最新推荐文章于 2024-07-21 11:20:00 发布
阅读量383 收藏
点赞数 16
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61219098/article/details/133976542
版权

文章目录


本文介绍了一种使用字符串替换的方法来计算数学表达式的值。相对于使用栈的方式，这种方法效率较低。这种计算器支持带括号的四则运算。

仅支持四则运算和括号的计算器

这部分代码实现了一个简单的计算器，它可以处理带有括号的四则运算表达式，并输出正确的计算结果；如果表达式输入有误或出现了分母为零等情况将返回nan。代码如下：

#include <string>
#include <vector>
#include <math.h>
using namespace std;
// 仅支持四则运算的计算器
double _cal(string s)
{
    string s1;
    string::iterator a, b, i; // a记录'(',b记录')'
    string::size_type n = 0;
    int l;
    if (false)
    F:
        s.replace(a, i + 1, to_string(_cal(string(a + 1, i))).c_str()); // 递归计算括号
R:
    i = s.begin();
    while (i < s.end())
    {
        if (*i == ' ' || *i == '\t')
        {
            s.erase(i);
            goto R;
        }
        if (*i == '(')
        {
            if (!n++)
                a = i;
        }
        else if (*i == ')')
        {
            if (!--n)
                goto F;
        }
        else if (*i != '\0' && *i != '.' && *i != 'e' && *i != '*' && *i != '-' && *i != '+' && *i != '/' && (*i < '0' || *i > '9') || (*i == '/' && *(i + 1) == '0' && *(i + 2) != '.'))
            return NAN; // 不是数学表达式
        ++i;
    }
    if (n)
        return NAN; // 左括号个数不等于右括号个数
    vector<string::size_type> u;
    /* k用作bool数组
     * 第一位表示第一个数字的正负性
     * 第二位表示第二个数字的正负性
     * 第三位表示第一个数字是否为字符串首个数字
     */
    unsigned char k('\0');
    // 计算乘除
    for (b = a = s.begin(); a < s.end(); ++a)
        if (*a == '*' || *a == '/')
            u.push_back(a - b);
    while (u.size())
    {
        i = a = b = s.begin() + u[0];
        while ((*--b >= '0' && *b <= '9') || *b == '.' || *b == 'e')
            if (b == s.begin())
            {
                k = 4;
                goto G;
            }
        // n记录第一个数字的首位的位置
        k += *b == '-';
        if (*b == '-')
            n = b - s.begin();
        else
            n = ++b - s.begin();
    G:
        double t = stod(string(b, a++));
        do
            if (++a == s.end())
                break;
        while ((*a >= '0' && *a <= '9') || *a == '.' || *a == 'e');
        double w = stod(string(i + 1, a));
        k += (w < 0) * 2;
        if (*i == '*')
        {
            l = (s1 = to_string(t * w)).size() - (a - b);
            s.replace(b, a, s1.c_str());
        }
        else if (w)
        {
            l = (s1 = to_string(t / w)).size() - (a - b);
            s.replace(b, a, s1.c_str());
        }
        else
            return NAN; // 除数为0
        switch (k)
        {
        case 2:
            s.erase(s.begin() + n - 1);
            break; // 删除-号前的+
        case 3:
            s.insert(s.begin() + n, '+'); // 在计算结果之前加一个+
        }
        u.erase(u.begin());
        for (auto &q : u)
            q += l;
    }
    // 计算加减
H:
    for (a = (b = s.begin()) + 1; a < s.end(); ++a)
        if (*a == '+')
        {
            if (*(a + 1) == '-' || *(a + 1) == '+')
            {
                s.erase(a);
                goto H;
            }
            u.push_back(a - b);
        }
        else if (*a == '-')
        {
            if (*(a + 1) == '-')
            {
                s.replace(a, a + 2, "+");
                goto H;
            }
            else if (*(a + 1) == '+')
            {
                s.erase(a + 1);
                goto H;
            }
            u.push_back(a - b);
        }
        else if(*a=='e'||*a=='E')
            if(*(a+1)=='-')
                ++a;
    while (u.size())
    {
        i = a = (b = s.begin()) + u[0];
        double t = stod(string(b, a++));
        do
            if (++a == s.end())
                break;
        while ((*a >= '0' && *a <= '9') || *a == '.' || *a == 'e');
        if (*i++ == '+')
            l = (s1 = to_string(t + stod(string(i, a)))).size() - (a - b);
        else
            l = (s1 = to_string(t - stod(string(i, a)))).size() - (a - b);
        s.replace(b, a, s1.c_str());
        u.erase(u.begin());
        for (auto &q : u)
            q += l;
    }
    return stod(s);
}

支持部分常用函数的计算器

实际使用中，我们可能会遇到诸如sin、exp、log等函数，这部分代码在基础计算器的基础上添加了对这些函数的支持。

/*
 * 计算器
 * 计算字符串s代表的值
 * 支持的函数：sqrt,sin,log,exp,pow,abs,cos,tan,asin,acos,atan
 * 支持无理数pi，但不支持e(e已经用作科学计数法的表示)，可以用exp(1)表示e
 */
double calStr(string s)
{
    if(s.empty())return 0;
    string::iterator i(s.begin());
    do
        switch (*i)
        {
        case 's':
        {
            string::iterator j(i);
            if (*++j == 'i')
            {
                if (*++j != 'n')
                    return NAN;
                if (*++j != '(')
                    return NAN;
                string::iterator k(++j);
                string::size_type n = 1;
                if (*k == '(')
                    ++n;
                else if (*k == ')')
                    return NAN;
                while (++k != s.end())
                    switch (*k)
                    {
                    case '(':
                        ++n;
                        break;
                    case ')':
                        if (!--n)
                            return calStr(s.replace(i, k + 1, to_string(sin(calStr(string(j, k))))));
                    }
                return NAN;
            }
            if (*j != 'q')
                return NAN;
            if (*++j != 'r')
                return NAN;
            if (*++j != 't')
                return NAN;
            if (*++j != '(')
                return NAN;
            string::iterator k(++j);
            string::size_type n = 1;
            if (*k == '(')
                ++n;
            else if (*k == ')')
                return NAN;
            while (++k != s.end())
                switch (*k)
                {
                case '(':
                    ++n;
                    break;
                case ')':
                    if (!--n)
                        return calStr(s.replace(i, k + 1, to_string(sqrt(calStr(string(j, k))))));
                }
            return NAN;
        }
        case 'l':
        {
            string::iterator j(i);
            if (*++j != 'o')
                return NAN;
            if (*++j != 'g')
                return NAN;
            if (*++j != '(')
                return NAN;
            string::iterator k(++j);
            string::size_type n = 1;
            if (*k == '(')
                ++n;
            else if (*k == ')')
                return NAN;
            while (++k != s.end())
                switch (*k)
                {
                case '(':
                    ++n;
                    break;
                case ')':
                    if (!--n)
                        return calStr(s.replace(i, k + 1, to_string(log(calStr(string(j, k))))));
                }
            return NAN;
        }
        case 'e':
        {
            string::iterator j(i);
            if (*++j != 'x')
                continue;
            if (*++j != 'p')
                return NAN;
            if (*++j != '(')
                return NAN;
            string::iterator k(++j);
            string::size_type n = 1;
            if (*k == '(')
                ++n;
            else if (*k == ')')
                return NAN;
            while (++k != s.end())
                switch (*k)
                {
                case '(':
                    ++n;
                    break;
                case ')':
                    if (!--n)
                        return calStr(s.replace(i, k + 1, to_string(exp(calStr(string(j, k))))));
                }
            return NAN;
        }
        case 'p':
        {
            string::iterator j(i);
            if (*++j != 'o')
            {
                if (*j == 'i')
                    return calStr(s.replace(i, ++j, "3.1415926535897932384626433832795"));
                return NAN;
            }
            if (*++j != 'w')
                return NAN;
            if (*++j != '(')
                return NAN;
            string::iterator k(++j), x;
            string::size_type n = 1;
            if (*k == '(')
                ++n;
            else if (*k == ')')
                return NAN;
            while (++k != s.end())
                switch (*k)
                {
                case ',':
                    x = k;
                    break;
                case '(':
                    ++n;
                    break;
                case ')':
                    if (!--n)
                        return calStr(s.replace(i, k + 1, to_string(pow(calStr(string(j, x)), calStr(string(x + 1, k))))));
                }
            return NAN;
        }
        case 'c':
        {
            string::iterator j(i);
            if (*++j != 'o')
                return NAN;
            if (*++j != 's')
                return NAN;
            if (*++j != '(')
                return NAN;
            string::iterator k(++j);
            string::size_type n = 1;
            if (*k == '(')
                ++n;
            else if (*k == ')')
                return NAN;
            while (++k != s.end())
                switch (*k)
                {
                case '(':
                    ++n;
                    break;
                case ')':
                    if (!--n)
                        return calStr(s.replace(i, k + 1, to_string(cos(calStr(string(j, k))))));
                }
            return NAN;
        }
        case 't':
        {
            string::iterator j(i);
            if (*++j != 'a')
                return NAN;
            if (*++j != 'n')
                return NAN;
            if (*++j != '(')
                return NAN;
            string::iterator k(++j);
            string::size_type n = 1;
            if (*k == '(')
                ++n;
            else if (*k == ')')
                return NAN;
            while (++k != s.end())
                switch (*k)
                {
                case '(':
                    ++n;
                    break;
                case ')':
                    if (!--n)
                        return calStr(s.replace(i, k + 1, to_string(tan(calStr(string(j, k))))));
                }
            return NAN;
        }
        case 'a':
        {
            string::iterator j(i);
            switch (*++j)
            {
            case 's':
            {
                if (*++j != 'i')
                    return NAN;
                if (*++j != 'n')
                    return NAN;
                if (*++j != '(')
                    return NAN;
                string::iterator k(++j);
                string::size_type n = 1;
                if (*k == '(')
                    ++n;
                else if (*k == ')')
                    return NAN;
                while (++k != s.end())
                    switch (*k)
                    {
                    case '(':
                        ++n;
                        break;
                    case ')':
                        if (!--n)
                            return calStr(s.replace(i, k + 1, to_string(asin(calStr(string(j, k))))));
                    }
                return NAN;
            }
            case 'c':
            {
                if (*++j != 'o')
                    return NAN;
                if (*++j != 's')
                    return NAN;
                if (*++j != '(')
                    return NAN;
                string::iterator k(++j);
                string::size_type n = 1;
                if (*k == '(')
                    ++n;
                else if (*k == ')')
                    return NAN;
                while (++k != s.end())
                    switch (*k)
                    {
                    case '(':
                        ++n;
                        break;
                    case ')':
                        if (!--n)
                            return calStr(s.replace(i, k + 1, to_string(acos(calStr(string(j, k))))));
                    }
                return NAN;
            }
            case 't':
            {
                if (*++j != 'a')
                    return NAN;
                if (*++j != 'n')
                    return NAN;
                if (*++j != '(')
                    return NAN;
                string::iterator k(++j);
                string::size_type n = 1;
                if (*k == '(')
                    ++n;
                else if (*k == ')')
                    return NAN;
                while (++k != s.end())
                    switch (*k)
                    {
                    case '(':
                        ++n;
                        break;
                    case ')':
                        if (!--n)
                            return calStr(s.replace(i, k + 1, to_string(atan(calStr(string(j, k))))));
                    }
                return NAN;
            }
            }
            if (*j != 'b')
                return NAN;
            if (*++j != 's')
                return NAN;
            if (*++j != '(')
                return NAN;
            string::iterator k(++j);
            string::size_type n = 1;
            if (*k == '(')
                ++n;
            else if (*k == ')')
                return NAN;
            while (++k != s.end())
                switch (*k)
                {
                case '(':
                    ++n;
                    break;
                case ')':
                    if (!--n)
                        return calStr(s.replace(i, k + 1, to_string(abs(calStr(string(j, k))))));
                }
            return NAN;
        }
        }
    while (++i != s.end());
    return _cal(s);
}

支持带未知数的函数表达式

若表达式中包含未知数x，可以使用如下函数来计算：

//在表达式中带有x
double calStr_x(string s,const double& x)
{
    for(auto p(s.begin());p!=s.end();++p)
        if(*p=='x')
            if(p==s.begin()||p+1==s.end()||*(p-1)!='e'||*(p+1)!='p')
                return calStr_x(s.replace(p,p+1,to_string(x)),x);
    return calStr(s);
}
zsc_118
关注
  • 16
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
输入一个加减乘除的字符串可以计算的计算器
03-25
输入一个加减乘除的字符串可以计算的计算器
对字符串计算器的实现分析
快乐小斗车
04-10 634
具体功能说明 比如字符串 “1+(2+3)-1*2+(6/2)-5”，这样的字符串计算得到值，使用调度场算法转为AST(抽象语法树) 比如字符串”a+(3-2)+b*c-(9/c)+d”，这里的a,b,c,d都是具体的变量值，实现对变量值的支持 AST如何转换为ExpressionTree实现Complie 具体的实现会后期放到github的个人主页项目中去
字符串计算器
mlvper的博客
07-24 3905
输入为中缀表达式字符串，计算结果。表达式可包含四则运算和括号。 实现步骤 1.将输入的中缀表达式转为后缀表达式 转化规则： 1.将数字直接添加到后缀表达式中 2.操作符栈为空或为扫描到左括号直接压入符号栈 3.当前操作符优先级大于栈顶优先级，直接压入符号栈 4.操作符优先级小于或等于栈顶，弹出所有大于或等于当前操作符的栈顶添加到后缀表达式中，该操作符入栈 5...
如何优雅的写出一个字符串计算器（JAVA）
qq_45789385的博客
04-24 2264
字符串计算器 坐标2020-4-24 经过-华为二面 面试官给了一张动态图，问我：二十分钟能写出一个简单的字符串计算器吗？ 略微思考：应该可以吧 接着在混乱的思路中，想用递归，又想用栈，最后写出一个无数空指针异常的计算器，结束后，痛定思痛，今天就教大家写一个字符串计算器。 首先，我们一定需要一个函数来判断字符是否是数字， public static boolean isNum(char x){ ...
字符串输入计算器
代码之家
08-25 1238
一般会在喜欢考字符串的笔试中遇到。 1. 无括号，简单计算器设置 leetcode地址：https://leetcode-cn.com/problems/basic-calculator-ii/ 首先给出python代码实现： class Solution: def calculate(self, s: str) -> int: d = 0 ...
基于C++设计简单计算器（LR 分析法）【100012180】
05-15
在本课程设计中，我们将探讨如何使用C++编程语言实现一个简单的计算器，主要涉及LR分析法这一关键概念。LR分析法是一种自底向上的语法分析方法，常用于编译器设计，它能处理右递归和左递归的文法。下面将详细解释LR...
C#使用宏替换字符串计算器源码
02-04
本文将深入探讨如何在C#中实现一种类似于宏替换的方法，以完成一个简单的字符串计算器功能。 首先，我们需要理解C#中的特性（Attributes）。特性是元数据的一种形式，它们可以附加到程序元素（如类、方法、属性等）...
jsq.rar_MFC实现计算器_mfc 计算器括号
09-24
MFC提供了CString类，它是C++中的一个字符串类，非常方便地处理字符串操作，如分割、查找和替换。 1. **解析表达式**：我们首先需要一个函数来接收用户的输入，将其转换为可处理的表达式。这可以通过读取CButton...
基本计算器leetcode-Strings-3:字符串-3
07-06
在这个场景中，我们关注的是两个与字符串处理相关的LeetCode问题：将整数转化为英文单词（Problem1 - Integer to English Words）以及实现一个基本的计算器（Problem2 - Basic Calculator）。这两个问题都是字符串...
C++ 人品计算器
06-29
7. **字符串操作**：`std::string`类提供了处理文本字符串的功能，如拼接、查找、替换等。在人品计算器中，可能需要处理用户输入的名字。 8. **错误处理**：为了提高程序的健壮性，可以添加异常处理机制，防止因...
字符串----计算器
csdn_edition的博客
03-10 1346
实现一个基本的计算器来计算一个简单的字符串表达式 s 的值。 示例 1： 输入：s = “1 + 1” 输出：2 示例 2： 输入：s = " 2-1 + 2 " 输出：3 示例 3： 输入：s = “(1+(4+5+2)-3)+(6+8)” 输出：23 提示： 1 <= s.length <= 3 * 105 s 由数字、’+’、’-’、’(’、’)’、和 ’ ’ 组成 s 表示一个有效的表达式 解法： 由于只有加减法，所以可以把括号全都展开来写，例如 2 - （1 - 3.
字符串操作，简单计算器的实现
honeyJ
02-20 976
str = "hello,world" print(str.upper()) print(str.lower()) print(str.capitalize()) print(str.title()) print(str.isalnum()) # 判断所有字符都是数字或字母 print(str.isalpha()) # 判断所有字符都是字母 print(str.isdigit()) #...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 237
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
C++ 继承篇
2301_79201049的博客
07-18 658
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 569
学懂C语言系列,C语言基本语法
C++笔记3：基类指针delete子类对象的内存泄漏问题
最新发布
subtitle_的博客
07-21 134
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 3999
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
【C++】获取环境变量
热门推荐
Badme
07-18 1万+
【C++】获取环境变量
C语言强化-1.数据结构概述
Annabelle___的博客
07-18 642
与408的关联：1. 逻辑结构和存储结构在选择题中会有涉及。2. 时间复杂度几乎是每一年大题必考内容！
C++实现的字符串处理函数系统
1. **字符串长度**：在C++中，计算字符串长度通常使用`std::strlen`函数，但在这个系统中，可能需要自定义一个函数来获取字符串的长度，通过对字符串结束标志'\0'的查找来实现。 2. **判断字符串是否为空**：通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zsc_118

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值