自己实现栈，通过此栈实现一个计算器

其他 2018-05-11 09:56:00 阅读次数: 1

题目：实现一个计算器，既能进行加减乘除的基本运算，又能支持带括号（只需要支持小括号即可）的优先级计算。
要求：使用面向对象思想，使用栈的数据结构实现括号匹配，栈的存储结构要求使用链表结构而非线性结构。
例如：
输入： 3 * （2 * 4 – 20 /5）+ 7
结果： 19

首先使用链表实现栈，为了方便编程，设计的栈的结构是这样的：
这里写图片描述

代码如下：

#include <iostream>

using namespace std;

template <typename T>
struct Node
{
    T m_data;
    Node<T> *m_pNext ;
    Node()
        :m_pNext(nullptr)
    {

    }
};

template<typename T>
class Stack
{
private:
    Node<T> *m_pTop;
    int     m_length;

public:
    Stack();
    void push(T parameter);     ///<入栈
    void pop();                 ///<出栈
    int size();                 ///<求栈大小
    void getTop(T &parameter);  ///<取栈顶元素
    bool isEmpty();             ///<判空
};

template <typename T>
Stack<T>::Stack()
    :m_pTop(nullptr)
    ,m_length(0)
{

}

template<typename T>
void Stack<T>::push(T parameter)
{
    Node<T> *newTop = new Node<T>;
    newTop->m_data = parameter;
    newTop->m_pNext = m_pTop;

    m_pTop = newTop;
    m_length ++;
}

template<typename T>
void Stack<T>::pop()
{
    if (m_length <= 0)
    {
        return;
    }
    Node<T> *parameter = m_pTop;
    T data = m_pTop->m_data;
    m_pTop = m_pTop->m_pNext;
    delete(parameter);
    m_length --;
}

template<typename T>
int Stack<T>::size()
{
    return m_length;
}

template<typename T>
void Stack<T>::getTop(T &parameter)
{
    if (!isEmpty())
    {
        parameter = m_pTop->m_data;
    }
}

template<typename T>
bool Stack<T>::isEmpty()
{
    if (m_length == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

然后就是实现计算器，为了方便扩展，计算器使用继承,实现多态：

mycalc.h

#include <iostream>

using namespace std;

class MyCalc
{
public:
    MyCalc();
    virtual ~MyCalc(){ }
    virtual int calculate(int,int) = 0;
};

/*加法运算*/
class AddCalc : public MyCalc
{
public:
    AddCalc();
    int calculate(int,int);
};

/*减法运算*/
class MinusCalc : public MyCalc
{
public:
    MinusCalc();
    int calculate(int,int);
};

/*乘法运算*/
class MultiCalc : public MyCalc
{
public:
    MultiCalc();
    int calculate(int,int);
};

/*除法运算*/
class DivCalc : public MyCalc
{
public:
    DivCalc();
    int calculate(int,int);
};

mycalc.cpp

#include "mycalc.h"

MyCalc::MyCalc()
{

}

AddCalc::AddCalc():MyCalc()
{

}

int AddCalc::calculate(int a, int b)
{
    return a+b;
}

MinusCalc::MinusCalc():MyCalc()
{

}

int MinusCalc::calculate(int a, int b)
{
    return b-a;
}

MultiCalc::MultiCalc():MyCalc()
{

}

int MultiCalc::calculate(int a, int b)
{
    return a*b;
}

DivCalc::DivCalc():MyCalc()
{

}

int DivCalc::calculate(int a, int b)
{
    if(0 == b)
    {
        cout<<"error......";
        return -1;
    }
    else
    {
        return b/a;
    }
}

逻辑实现如下：
中心思想是：将输入的中缀表达式通过栈的方式改为后缀表达式计算。
具体实现思路可看这里：https://blog.csdn.net/fan_xingwang/article/details/73476723
此处优化的是:
1.这里可以进行十位数以上的数字计算，编程思想是：从第一个字符开始遍历，直到找到一个不是数字的字符，然后给前面的每个数字乘10加上后面的数字，如123+4，找到加号，前面的数字为（1*10+2）*10+3
2.去除中英文符号所带来的乱码问题。
代码如下：

calculator.h

//这里使用了单例模式编写此类
#include <iostream>
#include <string>
#include "stack.h"
#include "mycalc.h"

using namespace std;

class Calculator
{
private:
    Calculator();
    static Calculator* m_pCalc;

public:  
    static pthread_mutex_t m_mtx;
    static Calculator* instance();
    ~Calculator();
    bool            isNum(char);            ///<判断是否是数字
    int             boolPriority(char);     ///<判断优先级
    int             calcResult(string);     ///<计算出结果
    string          changeFormat(string);   ///<转换格式

private:
    AddCalc*        m_add;                  ///<加法
    MinusCalc*      m_minu;                 ///<减法
    MultiCalc*      m_mult;                 ///<乘法
    DivCalc*        m_div;                  ///<除法    
};

calculator.cpp

#include "calculator.h"

/******************************************************************************
* Function: 判断是否是数字
* InPut   :char temp
* OutPut  :
* Return  :bool
*******************************************************************************/
Calculator::Calculator()
    :m_add(new AddCalc)
    ,m_minu(new MinusCalc)
    ,m_mult(new MultiCalc)
    ,m_div(new DivCalc)
{
    pthread_mutex_init(&m_mtx,0);
}

pthread_mutex_t Calculator::m_mtx;
Calculator* Calculator::m_pCalc = nullptr;
Calculator* Calculator::instance()
{
    if(nullptr == m_pCalc)
    {
        pthread_mutex_lock(&m_mtx);
        if(nullptr == m_pCalc)
        {
            m_pCalc = new Calculator();
        }
        pthread_mutex_unlock(&m_mtx);
    }
    return m_pCalc;
}

Calculator::~Calculator()
{
    if(nullptr != m_add)
    {
        delete m_add;
        m_add = nullptr;
    }

    if(nullptr != m_minu)
    {
        delete m_minu;
        m_minu = nullptr;
    }

    if(nullptr != m_mult)
    {
        delete m_mult;
        m_mult = nullptr;
    }

    if(nullptr != m_div)
    {
        delete m_div;
        m_div = nullptr;
    }
}

bool Calculator::isNum(char temp)
{
    if (temp>='0'&&temp<='9')
    {
        return true;
    }
    return false;
}

/******************************************************************************
* Function: 判断优先级
* InPut   :char temp
* OutPut  :
* Return  :int
*******************************************************************************/
int Calculator::boolPriority(char temp)
{
    if (temp=='+'||temp=='-')
    {
        return 0;
    }
    else if (temp == '*' || temp == '/')
    {
        return 1;
    }
    else if (temp == '(' || temp == ')')
    {
        return -1;
    }
    else if (temp=='#')
    {
        return -2;
    }

}

/******************************************************************************
* Function: 判断是否是数字
* InPut   :char temp
* OutPut  :
* Return  :bool
*******************************************************************************/
int Calculator::calcResult(string strTemp)
{
    Stack<int> numStack;
    Stack<char> opeStack;

    string strClac = changeFormat(strTemp);
    char top = '0';//储存计算过程中操作符栈的值
    int flagNumPre=-1;
    int flagNumNow=-1;
    int a=0, b=0;//储存计算过程中数据栈的值
    int number = 0;

    for (int i = 0; i < strClac.size();i++)
    {
        while(isNum(strClac[i]))
        {
            char temp = strClac[i];
            number = number*10+atoi(&temp);
            flagNumPre = i;
            i++;
        }
        if (!isNum(strClac[i]))
        {
            if(flagNumNow != flagNumPre)
            {
                numStack.push(number);
                number=0;
                flagNumNow = i-1;
            }
            if (opeStack.isEmpty())
            {
                opeStack.push(strClac[i]);
            }
            else
            {
                opeStack.getTop(top);
                if ((strClac[i] == '('))
                {
                    opeStack.push(strClac[i]);
                }
                else if (boolPriority(strClac[i])>boolPriority(top))
                {
                    opeStack.push(strClac[i]);
                }
                else
                {
                    while (boolPriority(strClac[i]) <= boolPriority(top))
                    {
                        if (top=='#'&&strClac[i]=='#')
                        {
                            int answer;
                            opeStack.pop();
                            numStack.getTop(answer);
                            numStack.pop();
                            return answer;
                        }
                        if (top=='('&&strClac[i]==')')
                        {
                            ++i;
                        }
                        if (strClac[i] == ')')
                        {
                            numStack.getTop(a);
                            numStack.pop();
                            numStack.getTop(b);
                            numStack.pop();
                        }
                        else if (boolPriority(strClac[i]) <= boolPriority(top))
                        {
                            numStack.getTop(a);
                            numStack.pop();
                            numStack.getTop(b);
                            numStack.pop();
                        }
                        if (top=='+')
                        {
                            b=m_add->calculate(a,b);
                            numStack.push(b);
                        }
                        else if (top == '-')
                        {
                            b=m_minu->calculate(a,b);
                            numStack.push(b);
                        }
                        else if (top == '*')
                        {
                            b=m_mult->calculate(a,b);
                            numStack.push(b);
                        }
                        else if (top == '/')
                        {
                            b=m_div->calculate(a,b);
                            numStack.push(b);
                        }
                        opeStack.pop();
                        opeStack.getTop(top);
                    }
                    opeStack.push(strClac[i]);//用于当top=='#'时，将最后一个运算符入栈
                }
            }
        }
    }
    cout<<"error......";
    return -1;
}

/******************************************************************************
* Function:中英文格式转换
* InPut   :char temp
* OutPut  :
* Return  :bool
* Other   :将中文括号及乱码替换掉
*******************************************************************************/
string Calculator::changeFormat(string strTemp)
{
    string strTemp1 = "";
    string strTemp2 = "";
    for (int i = 0; i < strTemp.size(); i++)
    {
        if (int(strTemp[i]) == -88)
        {
            strTemp[i] = '(';
            cout<<"Warnning:encoding format error\"(\""<<endl;
        }
        else if (int(strTemp[i]) == -87)
        {
            strTemp[i] = ')';
            cout<<"Warnning:encoding format error\")\""<<endl;
        }
        else if (int(strTemp[i]) < 40 || int(strTemp[i]) > 57)
        {
            strTemp1 = strTemp.substr(0,i);
            strTemp2 = strTemp.substr(i+1,strTemp.size()-(i+1));
            strTemp = strTemp1+strTemp2;
            i=i-1;
        }
    }
    string strClac = '#'+strTemp+'#';
    return strClac;
}

进行到这里本已经可以完成了，最后只需要在主函数调用就OK了。

#include <iostream>
#include "calculator.h"

using namespace std;

int main()
{
    Calculator* pCalc = new Calculator();
    string strClac;

    cout << "Input:";
    cin >> strClac;
    cout << "answer is:" <<pCalc->calcResult(strClac)<< endl;

    return 0;
}

效果图如下：
效果图
这里左右括号使用了中文符号，因此有提示，但是还是进行了计算，结果正确！

为了好看，方便，我又用Qt为此计算器写了界面，代码如下：

calcwidget.h

#include <QWidget>
#include <QTextBrowser>
#include <QPushButton>

class CalcWidget : public QWidget
{
    Q_OBJECT
public:
    CalcWidget(QWidget *parent = nullptr);

private:
    void initData();//数据初始化
    void initBrowser();//显示框初始化
    void initBtn();//按钮初始化
    void initLayout();//布局初始化

signals:

public slots:
    void slot_numOneBtnClicked();
    void slot_numTwoBtnClicked();
    void slot_numThreeBtnClicked();
    void slot_numFourBtnClicked();
    void slot_numFiveBtnClicked();
    void slot_numSixBtnClicked();
    void slot_numSevenBtnClicked();
    void slot_numEightBtnClicked();
    void slot_numNineBtnClicked();
    void slot_numZeroBtnClicked();
    void slot_operAddBtnClicked();
    void slot_operMinusBtnClicked();
    void slot_operMultBtnClicked();
    void slot_operDivBtnClicked();
    void slot_operEqualBtnClicked();
    void slot_operLeftBtnClicked();
    void slot_operRightBtnClicked();

private:
    QTextBrowser*   m_pTextBrowser;   ///<显示框

    QPushButton*    m_pNumOneBtn;     ///<数字1
    QPushButton*    m_pNumTwoBtn;     ///<数字2
    QPushButton*    m_pNumThreeBtn;   ///<数字3
    QPushButton*    m_pNumFourBtn;    ///<数字4
    QPushButton*    m_pNumFiveBtn;    ///<数字5
    QPushButton*    m_pNumSixBtn;     ///<数字6
    QPushButton*    m_pNumSevenBtn;   ///<数字7
    QPushButton*    m_pNumEightBtn;   ///<数字8
    QPushButton*    m_pNumNineBtn;    ///<数字9
    QPushButton*    m_pNumZeroBtn;    ///<数字0

    QPushButton*    m_pOperAddBtn;     ///<操作符+
    QPushButton*    m_pOperMinusBtn;   ///<操作符-
    QPushButton*    m_pOperMultBtn;    ///<操作符*
    QPushButton*    m_pOperDivBtn;     ///<操作符/
    QPushButton*    m_pOperEqualBtn;   ///<操作符=
    QPushButton*    m_pOperLeftBtn;    ///<操作符(
    QPushButton*    m_pOperRightBtn;   ///<操作符)

    QString         m_strCalc;         ///<待计算表达式
};

calcwidget.cpp

#include <QGridLayout>
#include <QDebug>
#include "calculator.h"
#include "calcwidget.h"

CalcWidget::CalcWidget(QWidget *parent) : QWidget(parent)
{
    setMaximumSize(310,320);
    setMinimumSize(310,320);
    initBrowser();
    initBtn();
    initLayout();
}

void CalcWidget::initData()
{
    m_strCalc = "";
}

void CalcWidget::initBrowser()
{
    m_pTextBrowser = new QTextBrowser(this);
    m_pTextBrowser->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);//设置垂直滚动条不可见
    m_pTextBrowser->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);//设置水平滚动条不可见
    m_pTextBrowser->setMaximumSize(280,55);
    m_pTextBrowser->setMinimumSize(280,55);
}

void CalcWidget::initBtn()
{
    m_pNumOneBtn = new QPushButton(this);
    m_pNumOneBtn->setText(tr("1"));
    m_pNumOneBtn->setMaximumSize(50,50);
    m_pNumOneBtn->setMinimumSize(50,50);
    connect(m_pNumOneBtn,&QPushButton::clicked,this,&CalcWidget::slot_numOneBtnClicked);

    m_pNumTwoBtn = new QPushButton(this);
    m_pNumTwoBtn->setText(tr("2"));
    m_pNumTwoBtn->setMaximumSize(50,50);
    m_pNumTwoBtn->setMinimumSize(50,50);
    connect(m_pNumTwoBtn,&QPushButton::clicked,this,&CalcWidget::slot_numTwoBtnClicked);

    m_pNumThreeBtn = new QPushButton(this);
    m_pNumThreeBtn->setText(tr("3"));
    m_pNumThreeBtn->setMaximumSize(50,50);
    m_pNumThreeBtn->setMinimumSize(50,50);
    connect(m_pNumThreeBtn,&QPushButton::clicked,this,&CalcWidget::slot_numThreeBtnClicked);

    m_pNumFourBtn = new QPushButton(this);
    m_pNumFourBtn->setText(tr("4"));
    m_pNumFourBtn->setMaximumSize(50,50);
    m_pNumFourBtn->setMinimumSize(50,50);
    connect(m_pNumFourBtn,&QPushButton::clicked,this,&CalcWidget::slot_numFourBtnClicked);

    m_pNumFiveBtn = new QPushButton(this);
    m_pNumFiveBtn->setText(tr("5"));
    m_pNumFiveBtn->setMaximumSize(50,50);
    m_pNumFiveBtn->setMinimumSize(50,50);
    connect(m_pNumFiveBtn,&QPushButton::clicked,this,&CalcWidget::slot_numFiveBtnClicked);

    m_pNumSixBtn = new QPushButton(this);
    m_pNumSixBtn->setText(tr("6"));
    m_pNumSixBtn->setMaximumSize(50,50);
    m_pNumSixBtn->setMinimumSize(50,50);
    connect(m_pNumSixBtn,&QPushButton::clicked,this,&CalcWidget::slot_numSixBtnClicked);

    m_pNumSevenBtn = new QPushButton(this);
    m_pNumSevenBtn->setText(tr("7"));
    m_pNumSevenBtn->setMaximumSize(50,50);
    m_pNumSevenBtn->setMinimumSize(50,50);
    connect(m_pNumSevenBtn,&QPushButton::clicked,this,&CalcWidget::slot_numSevenBtnClicked);

    m_pNumEightBtn = new QPushButton(this);
    m_pNumEightBtn->setText(tr("8"));
    m_pNumEightBtn->setMaximumSize(50,50);
    m_pNumEightBtn->setMinimumSize(50,50);
    connect(m_pNumEightBtn,&QPushButton::clicked,this,&CalcWidget::slot_numEightBtnClicked);

    m_pNumNineBtn = new QPushButton(this);
    m_pNumNineBtn->setText(tr("9"));
    m_pNumNineBtn->setMaximumSize(50,50);
    m_pNumNineBtn->setMinimumSize(50,50);
    connect(m_pNumNineBtn,&QPushButton::clicked,this,&CalcWidget::slot_numNineBtnClicked);

    m_pNumZeroBtn = new QPushButton(this);
    m_pNumZeroBtn->setText(tr("0"));
    m_pNumZeroBtn->setMaximumSize(170,50);
    m_pNumZeroBtn->setMinimumSize(170,50);
    connect(m_pNumZeroBtn,&QPushButton::clicked,this,&CalcWidget::slot_numZeroBtnClicked);

    m_pOperAddBtn = new QPushButton(this);
    m_pOperAddBtn->setText(tr("+"));
    m_pOperAddBtn->setMaximumSize(50,50);
    m_pOperAddBtn->setMinimumSize(50,50);
    connect(m_pOperAddBtn,&QPushButton::clicked,this,&CalcWidget::slot_operAddBtnClicked);

    m_pOperMinusBtn = new QPushButton(this);
    m_pOperMinusBtn->setText(tr("-"));
    m_pOperMinusBtn->setMaximumSize(50,50);
    m_pOperMinusBtn->setMinimumSize(50,50);
    connect(m_pOperMinusBtn,&QPushButton::clicked,this,&CalcWidget::slot_operMinusBtnClicked);

    m_pOperMultBtn = new QPushButton(this);
    m_pOperMultBtn->setText(tr("*"));
    m_pOperMultBtn->setMaximumSize(50,50);
    m_pOperMultBtn->setMinimumSize(50,50);
    connect(m_pOperMultBtn,&QPushButton::clicked,this,&CalcWidget::slot_operMultBtnClicked);

    m_pOperDivBtn = new QPushButton(this);
    m_pOperDivBtn->setText(tr("/"));
    m_pOperDivBtn->setMaximumSize(50,50);
    m_pOperDivBtn->setMinimumSize(50,50);
    connect(m_pOperDivBtn,&QPushButton::clicked,this,&CalcWidget::slot_operDivBtnClicked);

    m_pOperEqualBtn = new QPushButton(this);
    m_pOperEqualBtn->setText(tr("="));
    m_pOperEqualBtn->setMaximumSize(50,110);
    m_pOperEqualBtn->setMinimumSize(50,110);
    connect(m_pOperEqualBtn,&QPushButton::clicked,this,&CalcWidget::slot_operEqualBtnClicked);

    m_pOperLeftBtn = new QPushButton(this);
    m_pOperLeftBtn->setText(tr("("));
    m_pOperLeftBtn->setMaximumSize(50,50);
    m_pOperLeftBtn->setMinimumSize(50,50);
    connect(m_pOperLeftBtn,&QPushButton::clicked,this,&CalcWidget::slot_operLeftBtnClicked);

    m_pOperRightBtn = new QPushButton(this);
    m_pOperRightBtn->setText(tr(")"));
    m_pOperRightBtn->setMaximumSize(50,50);
    m_pOperRightBtn->setMinimumSize(50,50);
    connect(m_pOperRightBtn,&QPushButton::clicked,this,&CalcWidget::slot_operRightBtnClicked);
}

void CalcWidget::initLayout()
{
    QGridLayout* pGridLayout = new QGridLayout(this);
    pGridLayout->addWidget(m_pTextBrowser,0,0,1,5);
    pGridLayout->addWidget(m_pNumNineBtn,1,2,1,1);
    pGridLayout->addWidget(m_pNumEightBtn,1,1,1,1);
    pGridLayout->addWidget(m_pNumSevenBtn,1,0,1,1);
    pGridLayout->addWidget(m_pNumSixBtn,2,2,1,1);
    pGridLayout->addWidget(m_pNumFiveBtn,2,1,1,1);
    pGridLayout->addWidget(m_pNumFourBtn,2,0,1,1);
    pGridLayout->addWidget(m_pNumThreeBtn,3,2,1,1);
    pGridLayout->addWidget(m_pNumTwoBtn,3,1,1,1);
    pGridLayout->addWidget(m_pNumOneBtn,3,0,1,1);
    pGridLayout->addWidget(m_pNumZeroBtn,4,0,1,3);

    pGridLayout->addWidget(m_pOperAddBtn,1,3,1,1);
    pGridLayout->addWidget(m_pOperMinusBtn,2,3,1,1);
    pGridLayout->addWidget(m_pOperMultBtn,3,3,1,1);
    pGridLayout->addWidget(m_pOperDivBtn,4,3,1,1);

    pGridLayout->addWidget(m_pOperLeftBtn,1,4,1,1);
    pGridLayout->addWidget(m_pOperRightBtn,2,4,1,1);
    pGridLayout->addWidget(m_pOperEqualBtn,3,4,2,1);

    this->setLayout(pGridLayout);
}

void CalcWidget::slot_numOneBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='1';
    }
    else
    {
        m_strCalc=m_strCalc+'1';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numTwoBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='2';
    }
    else
    {
        m_strCalc=m_strCalc+'2';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numThreeBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='3';
    }
    else
    {
        m_strCalc=m_strCalc+'3';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numFourBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='4';
    }
    else
    {
        m_strCalc=m_strCalc+'4';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numFiveBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='5';
    }
    else
    {
        m_strCalc=m_strCalc+'5';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numSixBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='6';
    }
    else
    {
        m_strCalc=m_strCalc+'6';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numSevenBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='7';
    }
    else
    {
        m_strCalc=m_strCalc+'7';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numEightBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='8';
    }
    else
    {
        m_strCalc=m_strCalc+'8';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numNineBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='9';
    }
    else
    {
        m_strCalc=m_strCalc+'9';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_numZeroBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='0';
    }
    else
    {
        m_strCalc=m_strCalc+'0';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_operAddBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='+';
    }
    else
    {
        m_strCalc=m_strCalc+'+';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_operMinusBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='-';
    }
    else
    {
        m_strCalc=m_strCalc+'-';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_operMultBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='*';
    }
    else
    {
        m_strCalc=m_strCalc+'*';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_operDivBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='/';
    }
    else
    {
        m_strCalc=m_strCalc+'/';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_operEqualBtnClicked()
{
    if(m_strCalc=="")
    {

    }
    else
    {
        m_strCalc=m_strCalc+'=';
        m_pTextBrowser->clear();
        m_pTextBrowser->append(m_strCalc);

        Calculator* pCalc = Calculator::instance();
        m_pTextBrowser->append(tr(""));
        m_pTextBrowser->append(QString::number(pCalc->calcResult(m_strCalc.toStdString())));

        m_strCalc.clear();
        m_strCalc = "";
    }
}

void CalcWidget::slot_operLeftBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc='(';
    }
    else
    {
        m_strCalc=m_strCalc+'(';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

void CalcWidget::slot_operRightBtnClicked()
{
    if(m_strCalc=="")
    {
        m_strCalc=')';
    }
    else
    {
        m_strCalc=m_strCalc+')';
    }
    m_pTextBrowser->clear();
    m_pTextBrowser->append(m_strCalc);
}

最终实现效果如下：
效果图

猜你喜欢

转载自blog.csdn.net/fan_xingwang/article/details/79856902
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022