• 嵌入式Qt 实现用户界面与业务逻辑分离

    一.基本程序框架一般包含

    二.框架的基本设计原则

    三.用户界面与业务逻辑的交互

     

     四.代码实现计算器用户界面与业务逻辑

    ICalculator.h

    1. #ifndef _ICALCULATOR_H_
    2. #define _ICALCULATOR_H_
    3.  
    4. #include 
    5.  
    6. class ICalculator
    7. {
    8. public:
    9.     virtual bool expression(const QString& exp) = 0;
    10.     virtual QString result() = 0;
    11. };
    12.  
    13. #endif

    QCalculator.h

    1. #ifndef _QCALCULATOR_H_
    2. #define _QCALCULATOR_H_
    3.  
    4. #include "QCalculatorUI.h"
    5. #include "QCalculatorDec.h"
    6.  
    7. class QCalculator
    8. {
    9. protected:
    10.     QCalculatorUI* m_ui;
    11.     QCalculatorDec m_cal;
    12.  
    13.     QCalculator();
    14.     bool construct();
    15. public:
    16.     static QCalculator* NewInstance();
    17.     void show();
    18.     ~QCalculator();
    19. };
    20.  
    21. #endif // QCALCULATOR_H

    QCalculator.cpp

    1. #include "QCalculator.h"
    2.  
    3. QCalculator::QCalculator()
    4. {
    5. }
    6.  
    7. bool QCalculator::construct()
    8. {
    9.     m_ui = QCalculatorUI::NewInstance();
    10.  
    11.     if( m_ui != NULL )
    12.     {
    13.         m_ui->setCalculator(&m_cal);
    14.     }
    15.  
    16.     return (m_ui != NULL);
    17. }
    18.  
    19. QCalculator* QCalculator::NewInstance()
    20. {
    21.     QCalculator* ret = new QCalculator();
    22.  
    23.     if( (ret == NULL) || !ret->construct() )
    24.     {
    25.         delete ret;
    26.         ret = NULL;
    27.     }
    28.  
    29.     return ret;
    30. }
    31.  
    32.  
    33. void QCalculator::show()
    34. {
    35.     m_ui->show();
    36. }
    37.  
    38. QCalculator::~QCalculator()
    39. {
    40.     delete m_ui;
    41. }

    QCalculatorDec.h

    1. #ifndef _CALCULATORCORE_H_
    2. #define _CALCULATORCORE_H_
    3.  
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #include "ICalculator.h"
    9.  
    10. class QCalculatorDec : public ICalculator
    11. {
    12. protected:
    13.     QString m_exp;
    14.     QString m_result;
    15.  
    16.     bool isDigitOrDot(QChar c);
    17.     bool isSymbol(QChar c);
    18.     bool isSign(QChar c);
    19.     bool isNumber(QString s);
    20.     bool isOperator(QString s);
    21.     bool isLeft(QString s);
    22.     bool isRight(QString s);
    23.     int priority(QString s);
    24.     bool match(QQueue& exp);
    25.     QString calculate(QQueue& exp);
    26.     QString calculate(QString l, QString op, QString r);
    27.     bool transform(QQueue& exp, QQueue& output);
    28.     QQueue split(const QString& exp);
    29. public:
    30.     QCalculatorDec();
    31.     ~QCalculatorDec();
    32.     bool expression(const QString& exp);
    33.     QString expression();
    34.     QString result();
    35. };
    36.  
    37. #endif

     QCalculatorDec.cpp

    1. #include "QCalculatorDec.h"
    2.  
    3. QCalculatorDec::QCalculatorDec()
    4. {
    5.     m_exp = "";
    6.     m_result = "";
    7. }
    8.  
    9. QCalculatorDec::~QCalculatorDec()
    10. {
    11.  
    12. }
    13.  
    14. bool QCalculatorDec::isDigitOrDot(QChar c)
    15. {
    16.     return (('0' <= c) && (c <= '9')) || (c == '.');
    17. }
    18.  
    19. bool QCalculatorDec::isSymbol(QChar c)
    20. {
    21.     return isOperator(c) || (c == '(') || (c == ')');
    22. }
    23.  
    24. bool QCalculatorDec::isSign(QChar c)
    25. {
    26.     return (c == '+') || (c == '-');
    27. }
    28.  
    29. bool QCalculatorDec::isNumber(QString s)
    30. {
    31.     bool ret = false;
    32.  
    33.     s.toDouble(&ret);
    34.  
    35.     return ret;
    36. }
    37.  
    38. bool QCalculatorDec::isOperator(QString s)
    39. {
    40.     return (s == "+") || (s == "-") || (s == "*") || (s == "/");
    41. }
    42.  
    43. bool QCalculatorDec::isLeft(QString s)
    44. {
    45.     return (s == "(");
    46. }
    47.  
    48. bool QCalculatorDec::isRight(QString s)
    49. {
    50.     return (s == ")");
    51. }
    52.  
    53. int QCalculatorDec::priority(QString s)
    54. {
    55.     int ret = 0;
    56.  
    57.     if( (s == "+") || (s == "-") )
    58.     {
    59.         ret = 1;
    60.     }
    61.  
    62.     if( (s == "*") || (s == "/") )
    63.     {
    64.         ret = 2;
    65.     }
    66.  
    67.     return ret;
    68. }
    69.  
    70. bool QCalculatorDec::expression(const QString& exp)
    71. {
    72.     bool ret = false;
    73.     QQueue<QString> spExp = split(exp);
    74.     QQueue<QString> postExp;
    75.  
    76.     m_exp = exp;
    77.  
    78.     if( transform(spExp, postExp) )
    79.     {
    80.         m_result = calculate(postExp);
    81.  
    82.         ret = (m_result != "Error");
    83.     }
    84.     else
    85.     {
    86.         m_result = "Error";
    87.     }
    88.  
    89.  
    90.     return ret;
    91. }
    92.  
    93. QString QCalculatorDec::result()
    94. {
    95.     return m_result;
    96. }
    97.  
    98. QQueue<QString> QCalculatorDec::split(const QString& exp)
    99. {
    100.     QQueue<QString> ret;
    101.     QString num = "";
    102.     QString pre = "";
    103.  
    104.     for(int i=0; i<exp.length(); i++)
    105.     {
    106.         if( isDigitOrDot(exp[i]) )
    107.         {
    108.             num += exp[i];
    109.             pre = exp[i];
    110.         }
    111.         else if( isSymbol(exp[i]) )
    112.         {
    113.             if( !num.isEmpty() )
    114.             {
    115.                 ret.enqueue(num);
    116.  
    117.                 num.clear();
    118.             }
    119.  
    120.             if( isSign(exp[i]) && ((pre == "") || (pre == "(") || isOperator(pre)) )
    121.             {
    122.                 num += exp[i];
    123.             }
    124.             else
    125.             {
    126.                 ret.enqueue(exp[i]);
    127.             }
    128.  
    129.             pre = exp[i];
    130.         }
    131.     }
    132.  
    133.     if( !num.isEmpty() )
    134.     {
    135.         ret.enqueue(num);
    136.     }
    137.  
    138.     return ret;
    139. }
    140.  
    141. bool QCalculatorDec::match(QQueue<QString>& exp)
    142. {
    143.     bool ret = true;
    144.     int len = exp.length();
    145.     QStack<QString> stack;
    146.  
    147.     for(int i=0; i<len; i++)
    148.     {
    149.         if( isLeft(exp[i]) )
    150.         {
    151.             stack.push(exp[i]);
    152.         }
    153.         else if( isRight(exp[i]) )
    154.         {
    155.             if( !stack.isEmpty() && isLeft(stack.top()) )
    156.             {
    157.                 stack.pop();
    158.             }
    159.             else
    160.             {
    161.                 ret = false;
    162.                 break;
    163.             }
    164.         }
    165.     }
    166.  
    167.     return ret && stack.isEmpty();
    168. }
    169.  
    170. bool QCalculatorDec::transform(QQueue<QString>& exp, QQueue<QString>& output)
    171. {
    172.     bool ret = match(exp);
    173.     QStack<QString> stack;
    174.  
    175.     output.clear();
    176.  
    177.     while( ret && !exp.isEmpty() )
    178.     {
    179.         QString e = exp.dequeue();
    180.  
    181.         if( isNumber(e) )
    182.         {
    183.             output.enqueue(e);
    184.         }
    185.         else if( isOperator(e) )
    186.         {
    187.             while( !stack.isEmpty() && (priority(e) <= priority(stack.top())) )
    188.             {
    189.                 output.enqueue(stack.pop());
    190.             }
    191.  
    192.             stack.push(e);
    193.         }
    194.         else if( isLeft(e) )
    195.         {
    196.             stack.push(e);
    197.         }
    198.         else if( isRight(e) )
    199.         {
    200.             while( !stack.isEmpty() && !isLeft(stack.top()) )
    201.             {
    202.                 output.enqueue(stack.pop());
    203.             }
    204.  
    205.             if( !stack.isEmpty() )
    206.             {
    207.                 stack.pop();
    208.             }
    209.         }
    210.         else
    211.         {
    212.             ret = false;
    213.         }
    214.     }
    215.  
    216.     while( !stack.isEmpty() )
    217.     {
    218.         output.enqueue(stack.pop());
    219.     }
    220.  
    221.     if( !ret )
    222.     {
    223.         output.clear();
    224.     }
    225.  
    226.     return ret;
    227. }
    228.  
    229. QString QCalculatorDec::calculate(QString l, QString op, QString r)
    230. {
    231.     QString ret = "Error";
    232.  
    233.     if( isNumber(l) && isNumber(r) )
    234.     {
    235.         double lp = l.toDouble();
    236.         double rp = r.toDouble();
    237.  
    238.         if( op == "+" )
    239.         {
    240.             ret.sprintf("%f", lp + rp);
    241.         }
    242.         else if( op == "-" )
    243.         {
    244.             ret.sprintf("%f", lp - rp);
    245.         }
    246.         else if( op == "*" )
    247.         {
    248.             ret.sprintf("%f", lp * rp);
    249.         }
    250.         else if( op == "/" )
    251.         {
    252.             const double P = 0.000000000000001;
    253.  
    254.             if( (-P < rp) && (rp < P) )
    255.             {
    256.                 ret = "Error";
    257.             }
    258.             else
    259.             {
    260.                 ret.sprintf("%f", lp / rp);
    261.             }
    262.  
    263.         }
    264.         else
    265.         {
    266.             ret = "Error";
    267.         }
    268.     }
    269.  
    270.     return ret;
    271. }
    272.  
    273. QString QCalculatorDec::calculate(QQueue<QString>& exp)
    274. {
    275.     QString ret = "Error";
    276.     QStack<QString> stack;
    277.  
    278.     while( !exp.isEmpty() )
    279.     {
    280.         QString e = exp.dequeue();
    281.  
    282.         if( isNumber(e) )
    283.         {
    284.             stack.push(e);
    285.         }
    286.         else if( isOperator(e) )
    287.         {
    288.             QString rp = !stack.isEmpty() ? stack.pop() : "";
    289.             QString lp = !stack.isEmpty() ? stack.pop() : "";
    290.             QString result = calculate(lp, e, rp);
    291.  
    292.             if( result != "Error" )
    293.             {
    294.                 stack.push(result);
    295.             }
    296.             else
    297.             {
    298.                 break;
    299.             }
    300.         }
    301.         else
    302.         {
    303.             break;
    304.         }
    305.     }
    306.  
    307.     if( exp.isEmpty() && (stack.size() == 1) && isNumber(stack.top()) )
    308.     {
    309.         ret = stack.pop();
    310.     }
    311.  
    312.     return ret;
    313. }

    QCalculatorUI.h

    1. #ifndef _QCALCULATORUI_H_
    2. #define _QCALCULATORUI_H_
    3.  
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #include "ICalculator.h"
    9.  
    10. class QCalculatorUI : public QWidget
    11. {
    12.     Q_OBJECT
    13. private:
    14.     QLineEdit* m_edit;
    15.     QPushButton* m_buttons[20];
    16.     ICalculator* m_cal;
    17.  
    18.     QCalculatorUI();
    19.     bool construct();
    20. private slots:
    21.     void onButtonClicked();
    22. public:
    23.     static QCalculatorUI* NewInstance();
    24.     void show();
    25.     void setCalculator(ICalculator* cal);
    26.     ICalculator* getCalculator();
    27.     ~QCalculatorUI();
    28. };
    29.  
    30. #endif

    QCalculatorUI.cpp

    1. #include "QCalculatorUI.h"
    2. #include <QDebug>
    3.  
    4. QCalculatorUI::QCalculatorUI() : QWidget(NULL, Qt::WindowCloseButtonHint)
    5. {
    6.     m_cal = NULL;
    7. }
    8.  
    9. bool QCalculatorUI::construct()
    10. {
    11.     bool ret = true;
    12.     const char* btnText[20] =
    13.     {
    14.         "7", "8", "9", "+", "(",
    15.         "4", "5", "6", "-", ")",
    16.         "1", "2", "3", "*", "<-",
    17.         "0", ".", "=", "/", "C",
    18.     };
    19.  
    20.     m_edit = new QLineEdit(this);
    21.  
    22.     if( m_edit != NULL )
    23.     {
    24.         m_edit->move(10, 10);
    25.         m_edit->resize(240, 30);
    26.         m_edit->setReadOnly(true);
    27.         m_edit->setAlignment(Qt::AlignRight);
    28.     }
    29.     else
    30.     {
    31.         ret = false;
    32.     }
    33.  
    34.     for(int i=0; (i<4) && ret; i++)
    35.     {
    36.         for(int j=0; (j<5) && ret; j++)
    37.         {
    38.             m_buttons[i*5 + j] = new QPushButton(this);
    39.  
    40.             if( m_buttons[i*5 + j] != NULL )
    41.             {
    42.                 m_buttons[i*5 + j]->resize(40, 40);
    43.                 m_buttons[i*5 + j]->move(10 + (10 + 40)*j, 50 + (10 + 40)*i);
    44.                 m_buttons[i*5 + j]->setText(btnText[i*5 + j]);
    45.  
    46.                 connect(m_buttons[i*5 + j], SIGNAL(clicked()), this, SLOT(onButtonClicked()));
    47.             }
    48.             else
    49.             {
    50.                 ret = false;
    51.             }
    52.         }
    53.     }
    54.  
    55.     return ret;
    56. }
    57.  
    58. QCalculatorUI* QCalculatorUI::NewInstance()
    59. {
    60.     QCalculatorUI* ret = new QCalculatorUI();
    61.  
    62.     if( (ret == NULL) || !ret->construct() )
    63.     {
    64.         delete ret;
    65.         ret = NULL;
    66.     }
    67.  
    68.     return ret;
    69. }
    70.  
    71. void QCalculatorUI::show()
    72. {
    73.     QWidget::show();
    74.  
    75.     setFixedSize(width(), height());
    76. }
    77.  
    78. void QCalculatorUI::onButtonClicked()
    79. {
    80.     QPushButton* btn = dynamic_cast<QPushButton*>(sender());
    81.  
    82.     if( btn != NULL )
    83.     {
    84.         QString clickText = btn->text();
    85.  
    86.         if( clickText == "<-" )
    87.         {
    88.             QString text = m_edit->text();
    89.  
    90.             if( text.length() > 0 )
    91.             {
    92.                 text.remove(text.length()-1, 1);
    93.  
    94.                 m_edit->setText(text);
    95.             }
    96.         }
    97.         else if( clickText == "C" )
    98.         {
    99.             m_edit->setText("");
    100.         }
    101.         else if( clickText == "=" )
    102.         {
    103.             if( m_cal != NULL )
    104.             {
    105.                 m_cal->expression(m_edit->text());
    106.                 m_edit->setText(m_cal->result());
    107.             }
    108.         }
    109.         else
    110.         {
    111.             m_edit->setText(m_edit->text() + clickText);
    112.         }
    113.     }
    114. }
    115.  
    116. void QCalculatorUI::setCalculator(ICalculator* cal)
    117. {
    118.     m_cal = cal;
    119. }
    120.  
    121. ICalculator* QCalculatorUI::getCalculator()
    122. {
    123.     return m_cal;
    124. }
    125.  
    126. QCalculatorUI::~QCalculatorUI()
    127. {
    128.  
    129. }

    main.cpp

    1. #include 
    2.  
    3. #include "QCalculator.h"
    4.  
    5. int main(int argc, char *argv[])
    6. {
    7.     QApplication a(argc, argv);
    8.     QCalculator* cal = QCalculator::NewInstance();
    9.     int ret = -1;
    10.  
    11.     if( cal != NULL )
    12.     {
    13.         cal->show();
    14.  
    15.         ret = a.exec();
    16.  
    17.         delete cal;
    18.     }
    19.  
    20.     return ret;
    21. }

  • 相关阅读:
    Android Jetpack学习系列——Room
    00后卷王的自述，我难道真的很卷？
    还不懂Java线程池实现原理，看这一篇文章就够了
    企业电子招标采购系统源码Spring Boot + Mybatis + Redis + Layui + 前后端分离 构建企业电子招采平台之立项流程图
    二、Flink SQL 调优汇总
    module内包含第三方aar包，完整打包上传maven的方法
    滚雪球学Java(09-2)：Java中的关系运算符，你真的掌握了吗？
    L1-012 计算指数 C++
    keepalived实现nginx高可用
    03-基于Feign的远程调用,详解Feign的自定义配置和优化,创建Feign模块
  • 原文地址：https://blog.csdn.net/weixin_49303682/article/details/136282468