嵌入式Qt 计算器核心算法_3

}

bool QCalculatorDec::isNumber(QString s)
{
bool ret = false;

s.toDouble(&ret);

return ret;

}

bool QCalculatorDec::isOperator(QString s)
{
return (s == “+”) || (s == “-”) || (s == “*”) || (s == “/”);
}

bool QCalculatorDec::isLeft(QString s)
{
return (s == “(”);
}

bool QCalculatorDec::isRight(QString s)
{
return (s == “)”);
}

int QCalculatorDec::priority(QString s)
{
int ret = 0;

if( (s == "+") || (s == "-") )
{
    ret = 1;
}

if( (s == "*") || (s == "/") )
{
    ret = 2;
}

return ret;

}

bool QCalculatorDec::expression(const QString& exp)
{
bool ret = false;
QQueue spExp = split(exp);
QQueue postExp;

m_exp = exp;

if( transform(spExp, postExp) )
{
    m_result = calculate(postExp);

    ret = (m_result != "Error");
}
else
{
    m_result = "Error";
}


return ret;

}

QString QCalculatorDec::result()
{
return m_result;
}

QQueue QCalculatorDec::split(const QString& exp)
{
QQueue ret;
QString num = “”;
QString pre = “”;

for(int i=0; i<exp.length(); i++)
{
    if( isDigitOrDot(exp[i]) )
    {
        num += exp[i];
        pre = exp[i];
    }
    else if( isSymbol(exp[i]) )
    {
        if( !num.isEmpty() )
        {
            ret.enqueue(num);

            num.clear();
        }

        if( isSign(exp[i]) && ((pre == "") || (pre == "(") || isOperator(pre)) )
        {
            num += exp[i];
        }
        else
        {
            ret.enqueue(exp[i]);
        }

        pre = exp[i];
    }
}

if( !num.isEmpty() )
{
    ret.enqueue(num);
}

return ret;

}

bool QCalculatorDec::match(QQueue& exp)
{
bool ret = true;
int len = exp.length();
QStack stack;

for(int i=0; i<len; i++)
{
    if( isLeft(exp[i]) )
    {
        stack.push(exp[i]);
    }
    else if( isRight(exp[i]) )
    {
        if( !stack.isEmpty() && isLeft(stack.top()) )
        {
            stack.pop();
        }
        else
        {
            ret = false;
            break;
        }
    }
}

return ret && stack.isEmpty();

}

bool QCalculatorDec::transform(QQueue& exp, QQueue& output)
{
bool ret = match(exp);
QStack stack;

output.clear();

while( ret && !exp.isEmpty() )
{
    QString e = exp.dequeue();

    if( isNumber(e) )
    {
        output.enqueue(e);
    }
    else if( isOperator(e) )
    {
        while( !stack.isEmpty() && (priority(e) <= priority(stack.top())) )
        {
            output.enqueue(stack.pop());
        }

        stack.push(e);
    }
    else if( isLeft(e) )
    {
        stack.push(e);
    }
    else if( isRight(e) )
    {
        while( !stack.isEmpty() && !isLeft(stack.top()) )
        {
            output.enqueue(stack.pop());
        }

        if( !stack.isEmpty() )
        {
            stack.pop();
        }
    }
    else
    {
        ret = false;
    }
}

while( !stack.isEmpty() )
{
    output.enqueue(stack.pop());
}

if( !ret )
{
    output.clear();
}

return ret;

}

QString QCalculatorDec::calculate(QString l, QString op, QString r)
{
QString ret = “Error”;

if( isNumber(l) && isNumber(r) )
{
    double lp = l.toDouble();
    double rp = r.toDouble();

    if( op == "+" )
    {
        ret.sprintf("%f", lp + rp);
    }
    else if( op == "-" )
    {
        ret.sprintf("%f", lp - rp);
    }
    else if( op == "*" )
    {
        ret.sprintf("%f", lp * rp);
    }
    else if( op == "/" )
    {
        const double P = 0.000000000000001;

        if( (-P < rp) && (rp < P) )

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新！！

3950525)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新！！