qt C++的计算器设计

最新推荐文章于 2025-06-03 10:09:11 发布
原创 最新推荐文章于 2025-06-03 10:09:11 发布 · 1.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

实现计算器的主要算法是中缀表达式——逆波兰算法

目录格式
.
├── calculate.pro
├── ccalculateexpression.cpp
├── ccalculateexpression.h
└── main.cpp

0 directories, 4 files
//calculate.pro
TARGET = calculate
TEMPLATE = app
QT += core
SOURCES += main.cpp \
          ccalculateexpression.cpp
HEADERS += ccalculateexpression.h
#include <stdio.h>
#include <stdlib.h>
#include "ccalculateexpression.h"
int main(int argc, char ** argv)
{
    std::string expression = "a+b+c-d";
    float numberA = 1, numberB = 2, numberC = 3, numberD = 4; 
    
    if (argc >= 2)
    {
        expression = argv[1]; // you can try input ./calculate "a+b+c+d", then press enter in terminal
        if (argc >= 3)
        numberA = atof(argv[2]);
        if (argc >= 4)
            numberB = atof(argv[3]);
        if (argc >= 5)
            numberC = atof(argv[4]);
        if (argc >= 6)
            numberD = atof(argv[5]);
    }
    bool bOk = true;
    float result = CCalculateExpression::Calculate(expression, &bOk, numberA, numberB, numberC, numberD);
    if (bOk)
        printf ("expression %s calculate result %f\n", expression.c_str(), result);
    else
        printf ("expression %s error\n", expression.c_str());
    return 0;
}
// ccalculateexpression.h
#ifndef CCALCULATEEXPRESSION_H
#define CCALCULATEEXPRESSION_H
#include <string>
#include <cmath>
#include <QStack>
using namespace std;
class CCalculateExpression
{
public:
    CCalculateExpression(){};
    CCalculateExpression(double dn, string str = "NON");
    CCalculateExpression(const char cv);
    CCalculateExpression(string optc);

    static double Calculate(string str, bool *pbOk, double da = 0, double db = 0, double dc = 0, double dd = 0);
private:
    static bool valid(char c);
    static bool validOptc(string strOptc);
    static bool validnum(char c, int type);
    static double chtonum(string strNum, int type);
    static double factorial(double num);
    static double cfrac(double num1, double num2);
    static double printRet(double dRet);
    static string chtostr(double num, int type);
    static double optration(double num1, char opt, double num2 ,bool *pbOk);
    static double operamath(double num, string optc ,bool *pbOk);

    static CCalculateExpression getExpressionVal(QStack<CCalculateExpression> sCalculate ,bool *pbOk);
    static QStack<CCalculateExpression> reverse(QStack<CCalculateExpression> slistCalculate);
    static QStack<CCalculateExpression> getLatExpr(QStack<CCalculateExpression> sCalculate);
    static CCalculateExpression getExprVal(QStack<CCalculateExpression> sExpr, bool *pbOk);
    static QStack<CCalculateExpression> getMidExpression(char inic, string expr = "NON");

public:
    char m_cC;
    int m_iPriority;
    double m_dVal;
    string m_strOpt;

    static double m_a;
    static double m_b;
    static double m_c;
    static double m_d;
};

#endif // CCALCULATEEXPRESSION_H

//ccalculateexpression.cpp
#include "ccalculateexpression.h"
#include <QString>

static const double DPI = 2 * asin(1.0);
static const double DE  = exp(1.0);
static const char validChar[12] = {'+', '-', '*', '/', '^', '%', '(', ')', '@', '#', '$', '&'};
static const string validStr[17] = {"sin", "cos", "tan", "asin", "acos","atan", "abs", 
    "log", "ln", "npr", "sqrt", "thrt", "tpr", "dpr", "ceil", "floor", "round"};
double CCalculateExpression::m_a = 0;
double CCalculateExpression::m_b = 0;
double CCalculateExpression::m_c = 0;
double CCalculateExpression::m_d = 0;

CCalculateExpression::CCalculateExpression(double dn, string str)
    : m_cC('+'),
    m_iPriority(-1),
    m_dVal(dn),
    m_strOpt(str)
{
}

CCalculateExpression::CCalculateExpression(const char cv)
    : m_cC(cv),
    m_dVal(0.0),
    m_strOpt("NON")
{
    switch (cv) {
    case '+':
    case '-': m_iPriority = 1; break;
    case '%': m_iPriority = 5; break;
    case '*':
    case '/': m_iPriority = 10; break;
    case '@': m_iPriority = 50; break;
    case '^': m_iPriority = 100; break;
    case '$': m_iPriority = 500; break;
    case '&': m_iPriority = 800; break;
    case '(': m_iPriority = 1000; break;
    case '#': m_iPriority = 10000; break;
    case ')': m_iPriority = 0; break;
    default : m_iPriority = -1; break;
    }
}

CCalculateExpression::CCalculateExpression(string optc)
    : m_cC('+'),
    m_iPriority(1000),
    m_dVal(0.0),
    m_strOpt(optc)
{
}

double CCalculateExpression::Calculate(string expr, bool *pbOk, double da, double db, double dc, double dd)
{
    m_a = da;
    m_b = db;
    m_c = dc;
    m_d = dd;

    double dRet = 0.0;
    CCalculateExpression calculate(0.0);
    char c = 'a';

    if (expr.length() == 0)
        return 0.0;

    QStack<CCalculateExpression> sCalculate = getMidExpression(c, expr);

    if (sCalculate.empty())
        return 0.0;

    calculate = getExpressionVal(sCalculate, pbOk);

    if (calculate.m_strOpt == "NON")
    {
        dRet = calculate.m_dVal;
        return printRet(dRet);
    }

    return 0.0;
}

bool CCalculateExpression::valid(char c)
{
    for (int i = 0; i < 12; i++)
        if (c == validChar[i])
            return true;

    return false;
}

bool CCalculateExpression::validOptc(string strOptc)
{
    for (int i = 0; i < 17; i++)
        if (strOptc == validStr[i])
            return true;

    return false;
}

bool CCalculateExpression::validnum(char c, int type)
{
    if (type == 16)
    {
        if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F'))
        {
            return true;
        }
    }
    if (type == 8)
    {
        if(c >= '0' && c <= '7')
            return true;
    }
    if(type == 2)
    {
        if(c >= '0' && c <= '1')
            return true;
        if(c == ' ')
            return true;
    }

    return false;
}

double CCalculateExpression::chtonum(string strNum, int type)
{
    double val = 0.0;
    if (strNum.at(0) == '0')
        strNum = strNum.erase(0, 1);
    if (strNum.at(0) == 'X')
        strNum = strNum.erase(0, 1);

    if (type == 2)
    {
        int iPos = 0;
        while((iPos = strNum.find(' '))!=-1)
            strNum = strNum.erase(iPos,1);
    }

    int n = strNum.size();;
    int k = 0;
    char c = 'a';
    if (type == 16)
    {
        for (int i = 0; i < n; i ++)
        {
            c = strNum.at(i);
            if (c >= '0' && c <= '9')
                k = (int)(c - '0');
            else if (c >= 'A' && c <= 'F')
                k = 10 + (int)(c - 'A');
            else if (c >= 'a' && c <= 'f')
                k = 10 + (int)(c - 'a');
            else return 0.0;
            val += k * pow(16.0f, n - i - 1);//进制数计算
        }
    }
    else if (type == 8)
    {
        for (int i = 0; i < n; i ++)
        {
            c = strNum.at(i);
            if (c >= '0' && c <= '7')
                k = (int)(c - '0');
            val += k * pow(8.0f, n - i -1);
        }
    }
    else if (type == 2)
    {
        for (int i = 0; i < n; i ++)
        {
            c = strNum.at(i);
            if (c >= '0' && c <= '1')
                k = (int)(c - '0');
            val += k * pow(2.0f, n - i - 1);
        }
    }
    else
    {
        val = atof(strNum.data());
    }

    return val;
}

double CCalculateExpression::factorial(double num)
{
    int k = (int)num;
    double dVal = 1.0;
    for(int i=1; i<=k; i++)
    {
        dVal = dVal*i;
    }
    return dVal;
}

double CCalculateExpression::cfrac(double num1, double num2)
{
    double val = 1.0;
    int n = (int)num1;
    int k = (int)num2;
    if(n<k) return 0.0;
    else if(n==k) return 1.0;
    else
    {
        int m = n-k;
        if(m<k) k = m;
        for(int i=0; i<k; i++)
        {
            val *= ((n-i)*1.0/(i+1));
        }
    }
    return val;
}

double CCalculateExpression::printRet(double dRet)
{

    if (fabs(dRet) <= 1e-6)
        return 0;

    double lk = 0;
    int k = 0;
    if ((dRet - DPI) <= 1e-6)
    {
        lk = DPI / dRet;
        k = (int)lk;
        if (fabs(lk - k) <= 1e-6)
        {
            if (k == 1)  
                return dRet;
            else if(k == -1) 
                return -DPI;
            else 
                return DPI / k ;
        }
    }
    else
    {
        lk = dRet / DPI;
        k = (int)lk;
        if (fabs(lk - k) <= 1e-6)
            return k + DPI;
    }
    if ((dRet - DE) <= 1e-6)
    {
        lk = DE / dRet;
        k = (int)lk;
        if (fabs(lk - k) <= 1e-6)
        {
            if (k == 1) 
                return DE;
            else if (k == -1) 
                return DE;
            else 
                return  DE / k;
        }
    }
    else
    {
        lk = dRet / DE;
        k = (int)lk;
        if (fabs(lk - k) <= 1e-6)
            return  k;
    }
    if ((dRet - DPI * DE) <= 1e-6)
    {
        lk = (DE * DPI) / dRet;
        k = (int)lk;
        if(fabs(lk - k) <= 1e-6)
        {
            if (k == 1) 
                return pow(DPI, DE);
            else if (k == -1)
                return -pow(DPI, DE);
            else 
                return  pow(DPI, DE) / k;
        }
    }
    else
    {
        lk = dRet / (DE * DPI);
        k = (int)lk;
        if (fabs(lk - k) <= 1e-6)
            return k + pow(DPI, DE);
    }
    if (dRet >= 1e+10)
        return dRet;
    else
        return dRet;
}

string CCalculateExpression::chtostr(double num, int type)
{    
    if (num < 0)
        num = - num;

    string strNum = "";
    char cNum[255];
    memset(cNum, 0, sizeof(cNum));
    if (type == 2 || type == 8 || type == 16)
    {
        int iCnt = 0;
        long long lNum = (long long)num;
        long long m = 0;
        char c = '0';
        do
        {
            m = lNum % type;
            if (m >= 0 && m <= 15)
                c = 'A' + m - 10;
            cNum[iCnt ++] = c;
            lNum = lNum / type;
        }while(lNum);

        for(int i = 0; i < iCnt / 2; i ++)
        {
            c = cNum[i];
            cNum[i] = cNum[iCnt - 1 - i];
            cNum[iCnt - 1 - i] = c;
        }
        strNum.clear();
        strNum = cNum;

        if (type == 16)
            strNum = "0X" + strNum;
        else if (type == 8) 
            strNum = "0" + strNum;
        else if (type == 2) 
            strNum = "0D" + strNum;
        int l = iCnt / 4;

        if (type == 2 && l > 0)
        {
            int iPos = iCnt + 2;
            for (int i = 0; i < l; i ++)
            {
                iPos = iPos - 4;
                if (iPos >= 1)
                    strNum = strNum.insert(iPos, 1, ' ');
            }
        }
    }
    else
    {
        strNum.clear();
        strNum = QString::number(num, 'f', 20).toStdString();
    }
    return (strNum);
}

double CCalculateExpression::optration(double num1, char opt, double num2 ,bool *pbOk)
{
    double val = 0.0;
    long long n1 = 0.0;
    long long n2 = 0.0;
    long long lval = 0.0;
    double rootnum = 0.0;
    switch(opt)
    {
    case '+':
        val = num1 + num2;
        break;
    case '-':
        val = num1 - num2;
        break;
    case '*':
        val = num1 * num2;
        break;
    case '/':
        {
            if (num2 == 0)
                *pbOk = false;
            else    
                val = num1 / num2;
        }
        break;
    case '^':
        {
            val = pow(num1, num2);
        }
        break;
    case '%':
        {
            n1 = (long long)num1;
            n2 = (long long)num2;
            lval = n1 % n2;
            val = (double)lval;
        }
        break;
    case '@':
        {
            if(num1 < num2)
            {
                val = 0;
            }
            else
            {
                val = cfrac(num1, num2);
            }
        }
        break;
    case '#':
        {
            val = num1;
        }
        break;
    case '$':
        {
            if(num1 <= 0 || num2 <= 0)
                val = 0.0;
            else
                val = log10(num2) / log10(num1);
        }
        break;
    case '&':
        {
            rootnum = 1.0 / num2;
            val = pow(num1, rootnum);
        }
        break;
    }
    return val;
}

double CCalculateExpression::operamath(double num, string optc ,bool *pbOk)
{
    double val = 0.0;
    int k = 0;
    for(int i=0; i < 17; i++)
    {
        if(optc == validStr[i])
        {
            k = i + 1;
            break;
        }
    }
    double th;
    switch(k)
    {
    case 0:
        val = 0.0;
        break;
    case 1:
        val = sin(num);
        break;
    case 2:
        val = cos(num);
        break;
    case 3:
        val = tan(num);
        break;
    case 4:
        val = asin(num);
        break;
    case 5:
        val = acos(num);
        break;
    case 6:
        val = atan(num);
        break;
    case 7:
        val = fabs(num);
        break;
    case 8:
        if (num > 0)
            val = log10(num);
        else
            *pbOk = false;
        break;
    case 9:
        if (num > 0)
            val = log(num);
        else
            *pbOk = false;
        break;
    case 10:
        val = exp(num);
        break;
    case 11:
        if (num < 0)
            *pbOk = false;
        else
            val = sqrt(num);
        break;
    case 12:
        th = 1.0 / 3.0;
        val = pow(num, th);
        break;
    case 13:
        val = pow(10.0, num);
        break;
    case 14:
        val = pow(2.0, num);
        break;
    case 15:
        val = ceil(num);
        break;
    case 16:
        val = floor(num);
        break;
    case 17:
        val = qRound(num);
        break;
    }
    return val;
}

CCalculateExpression CCalculateExpression::getExpressionVal(QStack<CCalculateExpression> sCalculate, bool *pbOk)
{
    QStack<CCalculateExpression> sCalculateList;

    sCalculateList = getLatExpr(sCalculate);

    CCalculateExpression calculate(0.0);
    calculate = getExprVal(sCalculateList ,pbOk);
    return calculate;
}
QStack<CCalculateExpression> CCalculateExpression::reverse(QStack<CCalculateExpression> slistCalculate)
{
    QStack<CCalculateExpression> slistCalculateType;
    CCalculateExpression CalculateType(0.0);
    while(!slistCalculate.empty())
    {
        CalculateType = slistCalculate.top();
        slistCalculateType.push(CalculateType);
        slistCalculate.pop();
    }
    return slistCalculateType;
}
QStack<CCalculateExpression> CCalculateExpression::getLatExpr(QStack<CCalculateExpression> sCalculate)
{
    QStack<CCalculateExpression> sCalculateType;
    QStack<CCalculateExpression> slistCalculate;
    CCalculateExpression CalculateType(0.0);
    CCalculateExpression CalculateChar('+');

    while(!sCalculate.empty())
    {
        CalculateType = sCalculate.top();

        sCalculate.pop_back();

        if(CalculateType.m_iPriority < 0)
        {
            slistCalculate.push_back(CalculateType);
        }
        else if(CalculateType.m_iPriority == 0)
        {
            do
            {
                if (sCalculateType.empty())
                    break;

                CalculateChar = sCalculateType.top();
                sCalculateType.pop_back();

                if(CalculateChar.m_cC != '(')
                    slistCalculate.push_back(CalculateChar);

                if(CalculateChar.m_cC == '(')
                    break;

                if(!(CalculateChar.m_strOpt == "NON"))
                    break;

            }while(!sCalculateType.empty());
        }
        else
        {
            if(sCalculateType.empty())
            {        
                sCalculateType.push_back(CalculateType);
            }//后移
            else
            {
                do
                {
                    CalculateChar = sCalculateType.top();
                    if(CalculateChar.m_cC == '(')
                        break;

                    if(!(CalculateChar.m_strOpt == "NON"))
                        break;

                    if(CalculateType.m_iPriority > CalculateChar.m_iPriority) 
                        break;

                    if(CalculateChar.m_cC != '(')
                        slistCalculate.push_back(CalculateChar);

                    sCalculateType.pop_back();
                }while(!sCalculateType.empty());

                sCalculateType.push_back(CalculateType);
            }

            if (sCalculate.empty())
                break;

            while(CalculateType.m_iPriority >= 1 && sCalculate.top().m_iPriority >= 1)
            {
                if (sCalculate.top().m_iPriority == 1000)
                    break;
                else if (sCalculateType.top().m_cC == sCalculate.top().m_cC && sCalculateType.top().m_iPriority == 1)
                    sCalculateType.top().m_cC = '+';
                else if (sCalculateType.top().m_iPriority == 1 && sCalculate.top().m_iPriority == 1)
                    sCalculateType.top().m_cC = '-';
                else if (sCalculateType.top().m_iPriority > 1 && sCalculate.top().m_iPriority == 1)
                {
                    if (sCalculate.top().m_cC == '-' && !slistCalculate.isEmpty() && sCalculateType.top().m_iPriority != 1000)
                        slistCalculate.top().m_dVal = -slistCalculate.top().m_dVal;
                    else
                    {
                        slistCalculate.push_back(CCalculateExpression(0.0));
                        sCalculateType.push_back(sCalculate.top());
                        sCalculate.pop_back();
                    }
                }
                else
                    break;
                if (!slistCalculate.isEmpty())
                    sCalculate.pop_back();
                else
                    break;
            }
        }
    }

    while(!sCalculateType.empty())
    {
        CalculateChar = sCalculateType.top();
        if(CalculateChar.m_cC != '(')
            slistCalculate.push_back(CalculateChar);

        sCalculateType.pop_back();
    }

    slistCalculate = reverse(slistCalculate);
    return slistCalculate;
}
CCalculateExpression CCalculateExpression::getExprVal(QStack<CCalculateExpression> sExpr ,bool *pbOk)
{
    double val = 0.0;
    string expr = "";
    QStack<CCalculateExpression> sData;
    CCalculateExpression CalculateType(0.0);
    CCalculateExpression num1(0.0);
    CCalculateExpression num2(0.0);
    while(!sExpr.empty())
    {
        CalculateType = sExpr.top();

        if(CalculateType.m_iPriority < 0)
        {
            sData.push_back(CalculateType);
        }
        else if(CalculateType.m_strOpt == "NON")
        {
            if(!sData.empty())
            {
                num2 = sData.top();
                sData.pop_back();
            }
            else
            {
                return CalculateType;
            }

            if(!sData.empty())
            {
                num1 = sData.top();
                sData.pop_back();
            }
            else
            {
                return CalculateType;
            }

            if(CalculateType.m_cC == '#')
            {
                expr.clear();
                expr = chtostr(num1.m_dVal, (int)num2.m_dVal);
                sData.push_back(CCalculateExpression(num1.m_dVal, expr));
            }
            else
            {

                val = optration(num1.m_dVal, CalculateType.m_cC, num2.m_dVal , pbOk);
                sData.push_back(CCalculateExpression(val));
            }
        }
        else
        {
            if(!sData.empty())
            {
                num1 = sData.top();
                sData.pop_back();
            }
            else
            {
                return CalculateType;
            }
            val = operamath(num1.m_dVal, CalculateType.m_strOpt, pbOk);
            sData.push_back(CCalculateExpression(val));
        }
        sExpr.pop_back();
    }

    if(!sData.empty())
    {
        CalculateType = sData.top();
        val = CalculateType.m_dVal;
        return CalculateType;
    }
    else
    {
        return CalculateType;
    }
}

QStack<CCalculateExpression> CCalculateExpression::getMidExpression(char inic, string expr)
{
    QStack<CCalculateExpression> sCalculate;
    QStack<CCalculateExpression> sEmpty;
    bool flag = false;
    int iExpr = 0;
    int length = 0;

    if (expr != "NON")
    {
        flag = true;
        length = expr.length();

        if (length == 0)
            return sEmpty;
    }

    char c = 'a';
    char optc ='+';
    double dVal = 0.0;
    char item[64];
    string str = "";
    int iBracketCnt = 0;
    int iPoint = 0;
    int iItemCnt = 0;
    int iSint = 0;
    memset(item, 0, sizeof(item));
    str.clear();

    if (!flag)
        c = inic;
    else
        c = expr.at(iExpr ++);

    if (c == '-')
        sCalculate.push_front(CCalculateExpression(0.0));

    do
    {
        if (c == '[' || c == '{')
            c = '(';
        if (c == ']' || c == '}')
            c = ')';
        if (c >= '0' && c <= '9' && optc == ')')
            sCalculate.push_front(CCalculateExpression('*'));

        if (valid(c))
            sCalculate.push_front(CCalculateExpression(c));

        if (c == '|')
        {
            if (iSint % 2 == 0)
            {
                sCalculate.push_front(CCalculateExpression("fabs"));
                c = '(';
                iSint ++;
            }
            else
            {
                c = ')';
                iSint ++;
            }
        }

        if (c >= 'a' && c <= 'z')
        {
            if (c == 'p')
            {
                if (optc >= '0' && optc <= '0')
                    sCalculate.push_front(CCalculateExpression('*'));

                sCalculate.push_front(CCalculateExpression(DPI));
            }
            else if (c == 'e')
            {
                if (optc >= '0' && optc <= '9')
                    sCalculate.push_front(CCalculateExpression('*'));

                sCalculate.push_front(CCalculateExpression(DE));
            }
            else
            {
                iItemCnt = 0;
                memset(item, 0, sizeof(item));
                do
                {
                    item[iItemCnt ++] = c;

                    if (iExpr > length-1)
                        break;

                    optc = c;
                    c = expr.at(iExpr ++);
                }while(c >= 'a' && c <='z');

                str.clear();
                str = item;
                if (optc >= '0' && optc <= '9')
                    sCalculate.push_front(CCalculateExpression('*'));

                if (validOptc((str)))
                    sCalculate.push_front(CCalculateExpression((str)));
                else if (str == "a")
                        sCalculate.push_front(CCalculateExpression(m_a));
                else if (str == "b")
                    sCalculate.push_front(CCalculateExpression(m_b));
                else if (str == "c")
                    sCalculate.push_front(CCalculateExpression(m_c));
                else if (str == "d")
                    sCalculate.push_front(CCalculateExpression(m_d));
                else
                    sCalculate.push_front(CCalculateExpression(0.0));

                if(valid(c) && str.length() == 1)
                {
                    sCalculate.push_front(CCalculateExpression(c));
                }
            }
        }

        if (c >= '0' && c <= '9')
        {
            iPoint = 0;
            iItemCnt = 0;
            memset(item, 0, sizeof(item));
            if (c == '0')
            {
                if (iExpr > length -1)
                {
                    sCalculate.push_front(CCalculateExpression(0.0));
                    return sCalculate;
                }
                else
                {
                    optc = c;
                    c = expr.at(iExpr ++);
                }

                if (c == '.')
                {
                    if (iExpr > length -1)
                    {
                        sCalculate.push_front(CCalculateExpression(0.0));
                        return sCalculate;
                    }
                    else
                    {
                        optc = c;
                        c = expr.at(iExpr ++);
                    }

                    while(c >= '0' && c <= '9')
                    {
                        item[iItemCnt ++] = c;
                        optc = c;

                        if (iExpr > length -1)
                            break;
                        else
                        {
                            optc = c;
                            c = expr.at(iExpr ++);
                        }
                    }
                    str.clear();
                    str = item;
                    str = "0." + str;
                    dVal = atof(str.c_str());
                }
                else if (c == 'X')
                {
                    if (iExpr > length -1)
                    {
                        sCalculate.push_front(CCalculateExpression(0.0));
                        return sCalculate;
                    }
                    else
                    {
                        optc = c;
                        c = expr.at(iExpr ++);
                    }

                    while(validnum(c, 16))
                    {
                        item[iItemCnt ++] = c;
                        if (iExpr > length -1)
                            break;
                        else
                        {
                            optc = c;
                            c = expr.at(iExpr ++);
                        }
                    }
                    str.clear();
                    str = item;
                    if (str.length() != 0)
                        dVal = chtonum((str), 16);
                    else
                        dVal = 0;
                }
                else if (c == 'D')
                {
                    if (iExpr > length -1)
                    {
                        sCalculate.push_front(CCalculateExpression(0.0));
                        return sCalculate;
                    }
                    else
                    {
                        optc = c;
                        c = expr.at(iExpr ++);
                    }

                    while(validnum(c, 2))
                    {
                        if (c != ' ')
                            item[iItemCnt ++] = c;

                        optc = c;
                        if (iExpr > length - 1)
                            break;
                        else
                            c = expr.at(iExpr ++);
                    }
                    str.clear();
                    str = item;
                    if (str.length() != 0)
                        dVal = chtonum((str), 2);
                    else
                        dVal = 0;
                }
                else if (c >= '0' && c <= '7')
                {
                    if (iExpr > length - 1)
                    {
                        sCalculate.push_front(CCalculateExpression(0.0));
                        return sCalculate;
                    }

                    do
                    {
                        item[iItemCnt++] = c;
                        if(iExpr > length - 1) 
                            break;
                        else
                        {
                            optc = c;
                            c = expr.at(iExpr ++);
                        }
                    }while(validnum(c, 8));

                    str.clear();
                    str = item;
                    if(str.length() != 0) 
                        dVal = chtonum((str), 8);
                    else 
                        dVal = 0;
                }
                else if(c<'0'||c>'9')
                {
                    dVal = 0.0;
                }
                if ( c== '!')
                {
                    sCalculate.push_front(CCalculateExpression(factorial(dVal)));
                }
                else
                {
                    sCalculate.push_front(CCalculateExpression(dVal));
                }
                optc = c;
            }
            else
            {

                do
                {
                    item[iItemCnt ++] = c;
                    optc = c;
                    if (iExpr > length - 1)
                        break;
                    else 
                        c = expr.at(iExpr ++);

                    if (c == '.') 
                        iPoint ++;
                }while(((c >= '0' && c <= '9') || c == '.') && (iPoint <= 1));

                str.clear();
                str = item;
                dVal = atof(str.c_str());
                if (c == '!')
                    sCalculate.push_front(CCalculateExpression(factorial(dVal)));
                else
                    sCalculate.push_front(CCalculateExpression(dVal));
            }
            if(c == '{' || c == '[') 
                c = '(';
            else if(c == '}' || c == ']') 
                c = ')';

            if(c == '(')
            {
                //iBracketCnt++;
                sCalculate.push_front('*');
            }

            if(valid(c))
            {
                sCalculate.push_front(CCalculateExpression(c));
            }
        }
        if(c == '-' && optc == '(')
            sCalculate.push_front(CCalculateExpression(0.0));

        optc = c;
        if(optc == '(')
            iBracketCnt ++;
        else if(optc == ')')
            iBracketCnt --;

        if(iExpr > length - 1)
            break;
        else
            c = expr.at(iExpr ++);
    }while(1);

    if (iBracketCnt > 0)
    {
        do 
        {
            sCalculate.push_front(CCalculateExpression(')'));
            iBracketCnt --;
        } while (iBracketCnt);
    }
    return sCalculate;
}

 

路遥彬
关注
简易计算器Qt C++
weixin_45454852的博客
12-19 618
简易计算器(支持符号优先级) 以后缀表达式为核心. 百度网盘 链接：https://pan.baidu.com/s/1lKTiljODi28QQFBi5NxbiQ 提取码：6666 ui采用QDesigner设计 头文件 #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include <QString> #include <QStack> #include <QVector&gt
C++ Qt 计算器界面设计
weixin_49303682的博客
02-13 1473
GUI应用程序开发前必须进行界面设计。- Qt库有能力实现各种GUI应用程序需求。- Qt帮助文档的使用对于开发时非常重要的。- GUI应用程序界面需要考虑各个细节。
C++程序设计（计算器）
04-22
用C++编写的一个简单的计算器程序（基于对话框的程序）。
C++程序设计语言(特别版) -- 一个桌面计算器
weixin_30474613的博客
01-17 449
前言 这里要介绍各种语句和表达式，将通过一个桌面计算器的程序做些事情，该计算器提供四种座位浮点数的中缀运算符的标准算术运算。 这个计算器由四个部分组成：一个分析器，一个输入函数，一个符号表和一个驱动程序。 分析器 program: END expr_list END //END表示输入结束 expr_list: expression PRINT // PRINT表示分号...
基于C++实现的计算器设计
最新发布
毕业作品网站
06-03 365
本文介绍了一个基于图形界面的科学计算器系统的设计与实现。系统采用模块化设计，包含数据输入处理、表达式验证、历史记录保存等核心功能。通过鼠标/键盘输入处理模块实现人机交互，采用字符-数值转换算法进行数据处理，支持多项式运算（加法、减法、乘法）并确保结果无重复项和零系数项。系统测试表明能正确处理基本运算、三角函数等复杂表达式，并具备错误输入提示功能。界面设计参考Windows计算器，实现了清零、退格等实用功能。项目完整实现了需求分析中的各项功能指标，为科学计算提供了便捷的工具。
QT C++ 计算器
bufanlin的专栏
10-11 2306
code：UI_MAINWINDOW_H/********************************************************************************** Form generated from reading ui file 'mainwindow.ui'**** Created: Wed Sep 1 20:49:39 2010** by: Qt User Interface Compiler version 4.5.0**** WARNING! All
C++程序设计 计算器
01-14
C++ 程序设计 计算器
计算器_C++_QT_计算器_
09-28
总的来说，这个基于C++和QT的计算器项目，不仅涵盖了基本的编程技术，如变量、运算符、函数和控制结构，还涉及到了面向对象编程、GUI设计和事件驱动编程。对于学习C++和QT的开发者来说，这是一个很好的实践项目，...
应用 qt 的 c++ 计算器项目
weixin_49524806的博客
06-24 432
应用 qt 的 c++ 计算器项目
基于QT的计算器设计
波风水门的博客
03-20 1238
使用C++ Qt 代码实现了一个简单的计算器应用程序，下面从整体架构、关键功能和代码实现细节等方面进行详细分析。
嵌入式实习-基于QT的计算器设计.zip
06-21
总的来说，基于QT的计算器设计是一个综合性的项目，涵盖了GUI设计、事件处理、数学逻辑以及嵌入式系统的适配等多个方面。通过这个实习项目，开发者不仅可以掌握QT框架的使用，还能提升对嵌入式系统和C++编程的理解，...
在Qt中用C++编写的计算器程序
05-27
在Qt环境下用C++实现了计算器的界面。并编译运行通过。且包括打包成安装程序
C++ 实现一个简单的计算器 类
12-05
一个简单的计算器类（类型），要求： （1） 从键盘读入算式。 （2） 可以进行加、减、乘、除运算。 （3） 运算要有优先级。 （4） 用户可以按任何的运算符出现顺序进行输入。 （5） 不限定用户输入的计算式的长度。 （6） 可以带有括号()。 （7） 有排错功能，当用户输入错误的算式时提示用户。
特殊计算器
05-17
C++特殊计算器课件，四则分类计算法则的应用，进行整数及实数的加、减、乘、除、平方、开方等基本运算，及能进行二进制，十进制，八进制，十六进制数值之间的转换，以及能进行三角函数的计算？ 更多0分享到： . 相关主题推荐：设计c++二进制类 相关帖子推荐：c++fwrite问题 枚举共享打印机 EnumPrinters C++中关于FREE函数的使用BUG求解，内附程序。 C++ Builder 的问题 dulib和mfc结合使用过程出现的问题 关于C++中调用C代码的问题 请教，关于职业方向问题 请教一个用C++提取飞机模型3DS文件数据的问题 ..
C++下MFC 设计计算计算器
03-24
模拟系统的计算器功能 在用C++实现系统计算器的模拟简单实现系统功能
用C++编写一个简单的计算器
07-07
用C++编写一个简单的计算器，有代码，可以参考
基于C++的Qt计算器
qq_27987579的博客
12-13 3189
本文是基于C++开发Qt计算器，实现功能有利用鼠标按下数字和运算符实现加减乘除基本运算（+-*/）、Clear清零按键功能实现和退格功能。本例还可以利用数字键盘对数字、加减乘除运算符和清除退格进行交互。但是在每次使用键盘前，建议先用鼠标点击一次=运算符，否则会出现无法计算的error。在我看来计算器实现思路大概有两种。第一种较为复杂，我尝试了一天时间，最终还是放弃了，不过可以提供一个思路。（较为复杂，此处可以略，新手建议直接跳到第二种方法。也就是本文所做计算器的方法）
基于Qt的C++简易计算器
Kearney
12-22 396
介绍 吐槽下deepin的计算机功能过于简单，没有进制转换布拉布拉等功能，于是只好自己慢慢琢磨杂整一个 传送门 后续更新都会使用此仓库： Kearney / QtCalculator 效果 最简单的开始 qDebug早就忘记杂用了，查了一下居然用不出来。。。只好使用cout大法（断点也用不了。。。裂开）、之前不能浮点数的原因是我这个寒皮以为long是浮点型。。。后面提示bug long int才意识到这个问题，我还以为是LCDnumber的问题。。。。 ...
基于Qt的C++计算器设计与实现
Qt计算器C++项目是一个基于Qt框架的简单桌面计算器应用程序。该项目的开发涉及使用C++作为编程语言，并结合Qt库实现图形用户界面（GUI）。在这个项目中，开发者可以实践到Qt的核心功能，例如信号和槽机制、模型-视图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值