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

最新推荐文章于 2025-03-15 17:30:03 发布

樊同学爱编程

最新推荐文章于 2025-03-15 17:30:03 发布

阅读量3.1k

点赞数 6

分类专栏：编程练习文章标签：计算器单例模式多态面向对象

本文链接：https://blog.youkuaiyun.com/fan_xingwang/article/details/79856902

版权

编程练习专栏收录该内容

12 篇文章

订阅专栏

本文介绍了一种使用面向对象思想和栈的数据结构来实现带有括号优先级的计算器的方法。该计算器能够处理基本的算术运算，并通过栈将中缀表达式转换为后缀表达式进行计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：实现一个计算器，既能进行加减乘除的基本运算，又能支持带括号（只需要支持小括号即可）的优先级计算。
要求：使用面向对象思想，使用栈的数据结构实现括号匹配，栈的存储结构要求使用链表结构而非线性结构。
例如：
输入： 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.youkuaiyun.com/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);
}

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