界面展示
核心概念
二阶构造
思否
中缀表达式数字和运算符的分离算法
QQueue<QString> QCalculatorDec::split(const QString& exp)
{
QQueue<QString> ret;
QString num = “”;
QString pre = “”;
for(int i=0; i<exp.length(); i++)
{
if(isDigitOrDot(exp[i]) )
{
num += exp[i];
pre = exp[i];
}
else if(isSymbol(exp[i]) )
{
if(!num.isEmpty() )
{
ret.enqueue(num);
num.clear();
}
if(isSign(exp[i]) && ((pre == “”) || (pre == “(“) || (isOperator(pre)) ) )
{
num += exp[i];
}
else
{
ret.enqueue(exp[i]);
}
pre = exp[i];
}
}
if(!num.isEmpty() )
{
ret.enqueue(num);
}
return ret;
}
分析，所要计算的中缀表达式中包含：
数字和小数点【0 – 9 活 .】
符号位【+ 或 –】
运算符【+，-，*，/】
括号【(或)】
9.3 + (3 – -0.11) * 5
思想，以符号作为标记对表达式中的字符逐个访问
定义累计变量 num
当前字符 exp[i] 为数组或小数点时：
累计：num += exp[i]
当前字符 exp[i] 为符号时：
num 为运算数，分离并保存
若 exp[i] 为正负号：
累计符号位 + 和 –：num += exp[i]
若 exp[i] w 为运算符
分离并保存
中缀表达式转后缀表达式
bool QCalculatorDec::match(const QQueue<QString>& exp)
{
bool ret = true;
QStack<QString> stack;
for(int i=0; ret && (i<exp.length()); i++)
{
if(isLeft(exp[i]) )
{
stack.push(exp[i]);
}
else if(isRight(exp[i]) )
{
if(!stack.isEmpty() && isLeft(stack.top()) )
{
stack.pop();
}
else
{
ret = false;
}
}
}
return ret && stack.isEmpty();
}
确保表达式中的括号能够左右匹配（括号成对出现；左括号先于右括号出现）
bool QCalculatorDec::transform(QQueue<QString>& exp, QQueue<QString>& output)
{
bool ret = match(exp);
QStack<QString> stack;
output.clear();
while (ret && !exp.isEmpty() )
{
QString e = exp.dequeue();
if(isNumber(e) )
{
output.enqueue(e);
}
else if(isOperator(e) )
{
while((!stack.isEmpty()) && (priority(e) <= priority(stack.top())) )
{
output.enqueue(stack.pop());
}
stack.push(e);
}
else if(isLeft(e) )
{
stack.push(e);
}
else if(isRight(e) )
{
while(!stack.isEmpty() && !isLeft(stack.top()) )
{
output.enqueue(stack.pop());
}
if(!stack.isEmpty() )
{
stack.pop();
}
}
else
{
ret = false;
}
}
while(!stack.isEmpty() )
{
output.enqueue(stack.pop());
}
if(!ret)
{
output.clear();
}
return ret;
}
分析，中缀表达式转后缀表达式的过程类似编译过程：
四则运算表达式中的括号必须匹配
根据运算符优先级进行转换
转换后的表达时中没有括号
转换后可以顺序的计算出最终结果
思想
当前元素 e 为数字：输出
当前元素 e 为运算符：
1. 与栈顶元素进行优先级比较
2. 小于等于，讲栈顶元素输出，转 1
3. 大于，讲当前元素 e 入栈
当前元素 e 为左括号：入栈
当前元素 e 为右括号：
1. 弹出栈顶元素并输出，直至栈顶元素为左括号
2. 将栈顶的左括号从栈中弹出
9.3 + (3 – -0.11) * 5 ==> 9.3 3 -0.11 – 5 * +
后缀表达式计算结果
思想
遍历后缀表达时中的数字和运算符
当前元素为数组，进栈
当前元素为运算符：
从栈中弹出右操作符
从栈中弹出左操作数
根据符号进行运算
将运算结果压入栈中
遍历结束
栈中的唯一数字为运算结果
QString QCalculatorDec::calculator(QString l, QString op, QString r)
{
QString ret = “Error”;
if(isNumber(l) && isNumber(r) )
{
double lp = l.toDouble();
double rp = r.toDouble();
if(op == “+”)
{
ret.sprintf(“%f”, lp + rp);
}
else if(op == “-”)
{
ret.sprintf(“%f”, lp – rp);
}
else if(op == “*”)
{
ret.sprintf(“%f”, lp * rp);
}
else if(op == “/”)
{
const double p = 0.00000000001;
if((-p < rp) && (rp < p) )
{
ret.sprintf(“%f”, lp / rp);
}
}
}
return ret;
}
QString QCalculatorDec::calculator(QQueue<QString>& exp)
{
QString ret = “Error”;
QStack<QString> stack;
while(!exp.isEmpty() )
{
QString e = exp.dequeue();
if(isNumber(e) )
{
stack.push(e);
}
else if(isOperator(e) )
{
QString r = !stack.isEmpty() ? stack.pop() : “”;
QString l = !stack.isEmpty() ? stack.pop() : “”;
QString result = calculator(l, e, r);
if(result != “Error”)
{
stack.push(result);
}
else
{
break;
}
}
else
{
break;
}
}
if(exp.isEmpty() && (stack.size() == 1) && isNumber(stack.top()) )
{
ret = stack.pop();
}
return ret;
}
注意：
与数学相关的算法需要考虑除 0 的情况
若是浮点运算，避免代码中直接与 0 做相等比较
用户界面与交互逻辑分离
纯虚类 – 接口
定义接口类：
class ICalculator
{
public:
virtual bool expression(const QString& exp) = 0;
virtual QString result() = 0;
};
交互逻辑实现接口 (QCalculatorDec)：
class QCalculatorDec : public ICalculator
{
protected:
// …
public:
QCalculatorDec();
bool expression(const QString& exp);
QString result();
~QCalculatorDec();
};
用户界面使用接口 (QCalculatorUI):
class QCalculatorUI : public QWidget
{
Q_OBJECT
private:
// …
public:
static QCalculatorUI* NewInstance();
void setCalculator(ICalculator* cal);
ICalculator* getCalculator();
~QCalculatorUI();
};
模块之间需要进行解耦（强内聚，弱耦合）
每个模块只实现单一的功能
模块内部的子模块只为整体的单一功能而存在
模块之间通过约定好的接口进行交互
模块间不能出现循环依赖
用户界面与业务逻辑的交互：
计算机应用程序的整体框架：
总结
GUI 应用程序中，需要进行用户界面与业务逻辑的分离，在 C ++ 中使用纯虚类实现接口。
为保证得到合法的对象，二阶构造设计模式的使用是非常有必要的。
仓库
以上内容参考狄泰软件学院系列课程，请大家保护原创！