自己實現棧，通過此棧實現一個計算器

阿新 • • 發佈：2019-01-02

題目：實現一個計算器，既能進行加減乘除的基本運算，又能支援帶括號（只需要支援小括號即可）的優先順序計算。
要求：使用面向物件思想，使用棧的資料結構實現括號匹配，棧的儲存結構要求使用連結串列結構而非線性結構。
例如：
輸入： 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);
}

最終實現效果如下：
效果圖

自己實現棧，通過此棧實現一個計算器

自己實現棧，通過此棧實現一個計算器

佇列實現棧，兩個佇列實現一個棧方法詳解（含實現程式碼）

迷宮求解呼叫棧，及遞迴實現

資料結構棧（順序棧，鏈式棧，用棧實現計算器）

Java開發中，通過sql來實現過濾以及分頁

java內部類之成員內部類，通過內部類實現多繼承

AngularJS路由巢狀，通過ui-route實現深層路由

python中多執行緒的共享資料，通過queue來實現，內有生產者消費者經典模型的示例程式碼

Android 2個Service實現相互保活，通過bindservice來實現，不通過廣播實現

java網路程式設計，通過TCP,Socket實現多對一的區域網聊天室

Python元類實戰，通過元類實現資料庫ORM框架

資料結構——線性表：順序棧，鏈式棧（C++）

【劍指offer】包含min函式的棧，可以返回棧中的最小元素

【Android】android開發之splash閃屏頁的四種實現方式，啟動頁的實現教程。

通過介面獲取所有實現類以及通過註解獲取實現類的思路

鏈棧的置空入棧，出棧，和返回棧頂元素操作

棧操作包括入棧，出棧，清空棧，銷燬棧等

RadioButton的使用（三個button，實現互斥，一次只能選中一個）

java GC 棧（虛擬機器棧，本地方法棧)，堆（新生代、老年代），方法區（永久帶）等引數配置

S3C2440 RT3070實現無線路由器基於wpa_suppicant+udhcpc實現STA，hostapd+udhcpd+iptables實現softAP

自己實現棧，通過此棧實現一個計算器

相關推薦