案例:计算器(布局与信号槽的综合练习)
用 QGridLayout 搭按钮阵列,手写表达式求值器,练布局与信号槽
#这个案例做什么
从一个空白窗口开始,手写一个能算 3 + 4 * (2 - 1) ^ 2 的桌面计算器:不用 Designer 拖控件,全部代码搭界面;不用 QJSEngine 偷懒,自己实现一个表达式求值器;不用鼠标也能算,键盘直接敲。它是第六篇的开胃菜——代码量不大,但布局、信号槽、事件、字符串处理、样式表一次全用上,是检验前五篇基本功的最好方式。
功能清单:
- 支持
+ - * / % ^六种运算符、小括号、一元负号,正确处理优先级与结合性; - 点击按钮或敲键盘输入表达式,输入过程中实时预览当前结果;
C清空、⌫退格、±整体取反、=求值;- 除零、括号不匹配、非法字符给出中文错误提示;
- 全键盘操作:数字键、运算符键、回车求值、Esc 清空、Backspace 退格;
- 通过一份 QSS 把界面从系统默认样式改成深色主题。
#用到的知识点
| 知识点 | 出处 |
|---|---|
QGridLayout 网格布局、跨列 addWidget(w, r, c, rs, cs) | 第三篇第 7 章 布局管理 |
QPushButton、QLineEdit、QLabel | 第三篇第 6 章 常用基础控件 |
connect 的 Lambda 形式、信号槽的第二种写法 | 第三篇第 3 章 元对象系统与信号槽 |
keyPressEvent 事件重写、QKeyEvent::text() | 第三篇第 9 章 事件系统 |
QMainWindow + QStatusBar + central widget | 第三篇第 8 章 主窗口框架 |
QString / QChar / QVector(QList) | 第三篇第 5 章 Qt 核心数据类型 |
| Lambda 捕获与生命周期 | 第二篇第 1 章 Lambda 与可调用对象 |
| 栈结构、状态机思路 | 第一篇第 7 章 STL 容器 |
QSS 选择器与伪状态(:hover / :pressed) | 第四篇第 4 章 自定义控件与 QSS |
CMake + AUTOMOC + qt_add_executable | 第二篇第 5 章 工程化 |
#项目结构
calculator/
├── CMakeLists.txt
└── src/
├── main.cpp # 程序入口 + 全局 QSS
├── mainwindow.h
├── mainwindow.cpp # 界面搭建、按钮连接、键盘输入
├── expression.h
└── expression.cpp # 与界面完全无关的求值器把求值器放在独立文件里,是本篇反复强调的习惯:算法与界面解耦。这样 expression.cpp 可以单独写单元测试,换 QML 界面时一行都不用改。
cmake_minimum_required(VERSION 3.16)
project(Calculator LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON) # 有 Q_OBJECT 就必须开
find_package(Qt6 REQUIRED COMPONENTS Widgets)
qt_add_executable(Calculator
src/main.cpp
src/mainwindow.cpp
src/mainwindow.h
src/expression.cpp
src/expression.h
)
target_include_directories(Calculator PRIVATE src)
target_link_libraries(Calculator PRIVATE Qt6::Widgets)
# 源码里有中文(⌫、± 以及错误提示),MSVC 必须强制 UTF-8
if(MSVC)
target_compile_options(Calculator PRIVATE /utf-8)
endif()
if(APPLE)
set_target_properties(Calculator PROPERTIES MACOSX_BUNDLE TRUE)
endif()#核心实现
#表达式求值器:先把字符串切成 token
求值分两步:词法分析把 "3+4*(2-1)" 切成 [3][+][4][*][(][2][-][1][)],再由语法层按优先级计算。这里用经典的调度场算法(Shunting-yard):中缀转后缀,再对后缀表达式做一次线性扫描。
下面这个头文件刻意只依赖 QString,不碰任何 Qt 界面类。
// src/expression.h
#pragma once
#include <QString>
#include <QVector>
// 一个不依赖 QJSEngine 的极简表达式求值器,纯算法,可单测
class Expression
{
public:
struct Result
{
bool ok = false;
double value = 0.0;
QString error; // 失败时给用户的中文提示
};
// 支持 + - * / % ^ ( ),以及一元正负号
static Result evaluate(const QString &text);
};#词法分析与调度场算法
tokenize 里最关键的细节是一元运算符的判定:同一个 -,在 5-3 里是减号,在 (-3) 里是负号。判断依据是"上一个 token 结束后,当前是否期待一个操作数"。用 expectOperand 这个布尔量做状态机即可,遇到负号时补一个 0,把 -3 变成 0 - 3,后面就不需要任何特殊处理了。
// src/expression.cpp
#include "expression.h"
#include <QChar>
#include <cmath>
namespace {
enum class Kind { Number, Operator, LParen, RParen };
struct Token
{
Kind kind = Kind::Number;
double num = 0.0;
QChar op = '\0';
};
bool tokenize(const QString &text, QVector<Token> &out, QString &err)
{
int i = 0;
bool expectOperand = true; // 当前是否期待一个操作数
while (i < text.size()) {
const QChar c = text.at(i);
if (c.isSpace()) { ++i; continue; }
if (c.isDigit() || c == '.') {
const int begin = i;
bool hasDot = false;
while (i < text.size() && (text.at(i).isDigit() || text.at(i) == '.')) {
if (text.at(i) == '.') {
if (hasDot) { err = "小数点了两次"; return false; }
hasDot = true;
}
++i;
}
bool ok = false;
const double v = text.mid(begin, i - begin).toDouble(&ok);
if (!ok) { err = "数字格式不对"; return false; }
out.append({ Kind::Number, v, '\0' });
expectOperand = false;
continue;
}
if (c == '(') {
out.append({ Kind::LParen, 0.0, c });
++i;
expectOperand = true;
continue;
}
if (c == ')') {
out.append({ Kind::RParen, 0.0, c });
++i;
expectOperand = false;
continue;
}
if (QStringLiteral("+-*/%^").contains(c)) {
if (expectOperand) {
if (c == '-') { // 一元负号:补 0,写成 0 - x
out.append({ Kind::Number, 0.0, '\0' });
out.append({ Kind::Operator, 0.0, '-' });
++i;
continue; // 补完仍期待操作数
}
if (c == '+') { ++i; continue; } // 一元正号:直接丢弃
err = QString("运算符 '%1' 前面缺操作数").arg(c);
return false;
}
out.append({ Kind::Operator, 0.0, c });
++i;
expectOperand = true;
continue;
}
err = QString("不认识的字符 '%1'").arg(c);
return false;
}
return true;
}
int precedence(QChar op)
{
if (op == '+' || op == '-') return 1;
if (op == '*' || op == '/' || op == '%') return 2;
if (op == '^') return 3; // 幂运算优先级最高
return 0;
}
bool rightAssociative(QChar op) { return op == '^'; } // 2^3^2 == 2^(3^2)
bool apply(QChar op, double lhs, double rhs, double &result, QString &err)
{
switch (op.unicode()) {
case '+': result = lhs + rhs; return true;
case '-': result = lhs - rhs; return true;
case '*': result = lhs * rhs; return true;
case '/':
if (qFuzzyIsNull(rhs)) { err = "除数不能为 0"; return false; }
result = lhs / rhs;
return true;
case '%':
if (qFuzzyIsNull(rhs)) { err = "取余的右操作数不能为 0"; return false; }
result = std::fmod(lhs, rhs);
return true;
case '^':
result = std::pow(lhs, rhs);
if (std::isnan(result)) { err = "幂运算结果无效"; return false; }
return true;
}
err = "未知运算符";
return false;
}
} // namespace
Expression::Result Expression::evaluate(const QString &text)
{
Result r;
if (text.trimmed().isEmpty()) { r.error = "表达式为空"; return r; }
QVector<Token> tokens;
if (!tokenize(text, tokens, r.error)) return r;
// 中缀 -> 后缀(逆波兰式)
QVector<Token> output;
QVector<Token> ops;
for (const Token &t : tokens) {
switch (t.kind) {
case Kind::Number:
output.append(t);
break;
case Kind::Operator:
// 栈顶优先级更高,或同级且左结合时,先弹出
while (!ops.isEmpty() && ops.last().kind == Kind::Operator
&& (precedence(ops.last().op) > precedence(t.op)
|| (precedence(ops.last().op) == precedence(t.op)
&& !rightAssociative(t.op)))) {
output.append(ops.takeLast());
}
ops.append(t);
break;
case Kind::LParen:
ops.append(t);
break;
case Kind::RParen: {
bool matched = false;
while (!ops.isEmpty()) {
if (ops.last().kind == Kind::LParen) {
ops.removeLast();
matched = true;
break;
}
output.append(ops.takeLast());
}
if (!matched) { r.error = "括号不匹配"; return r; }
break;
}
}
}
while (!ops.isEmpty()) {
if (ops.last().kind == Kind::LParen) { r.error = "括号不匹配"; return r; }
output.append(ops.takeLast());
}
// 后缀求值:遇数字压栈,遇运算符弹两个数
QVector<double> nums;
for (const Token &t : output) {
if (t.kind == Kind::Number) { nums.append(t.num); continue; }
if (nums.size() < 2) { r.error = "表达式不完整"; return r; }
const double rhs = nums.takeLast();
const double lhs = nums.takeLast();
double v = 0;
if (!apply(t.op, lhs, rhs, v, r.error)) return r;
nums.append(v);
}
if (nums.size() != 1) { r.error = "表达式不完整"; return r; }
r.ok = true;
r.value = nums.first();
return r;
}#主窗口:一张表描述整个键盘
二十个按钮如果写二十行 addWidget,既啰嗦又难改。做法是把"按钮长什么样、放在哪、按下往表达式里塞什么"数据化,用一个数组描述,再循环生成。这是 Widgets 里最常用的界面生成套路。
// src/mainwindow.h
#pragma once
#include <QMainWindow>
class QGridLayout;
class QLabel;
class QLineEdit;
class QPushButton;
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = nullptr);
protected:
void keyPressEvent(QKeyEvent *event) override;
private:
void buildUi();
QPushButton *makeButton(const QString &text, int row, int col,
int rowSpan = 1, int colSpan = 1);
void handleKey(const QString &face); // 统一入口:按钮和键盘都走它
void insert(const QString &piece);
void backspace();
void clearAll();
void toggleSign();
void calculate();
void refreshPreview();
QString formatNumber(double v) const;
QLineEdit *m_display = nullptr;
QLabel *m_preview = nullptr;
QGridLayout *m_grid = nullptr;
};handleKey 是唯一的动作入口,参数是按钮表面文字。按钮点击和键盘输入都转成这个字符串再分发,两条输入路径共用一套逻辑,不会走着走着就分叉。
// src/mainwindow.cpp
#include "mainwindow.h"
#include "expression.h"
#include <QFont>
#include <QGridLayout>
#include <QHash>
#include <QKeyEvent>
#include <QLabel>
#include <QLineEdit>
#include <QPushButton>
#include <QStatusBar>
#include <QVBoxLayout>
#include <cmath>
namespace {
struct KeySpec
{
const char *face; // 按钮表面文字
int row;
int col;
};
// 5 行 × 4 列的按钮阵列,第 6 行放等宽 4 列的等号
const KeySpec kKeys[] = {
{ "C", 0, 0 }, { "(", 0, 1 }, { ")", 0, 2 }, { "⌫", 0, 3 },
{ "7", 1, 0 }, { "8", 1, 1 }, { "9", 1, 2 }, { "÷", 1, 3 },
{ "4", 2, 0 }, { "5", 2, 1 }, { "6", 2, 2 }, { "×", 2, 3 },
{ "1", 3, 0 }, { "2", 3, 1 }, { "3", 3, 2 }, { "-", 3, 3 },
{ "0", 4, 0 }, { ".", 4, 1 }, { "±", 4, 2 }, { "+", 4, 3 },
};
// 界面上的符号 -> 求值器认识的符号
const QHash<QString, QString> &faceToToken()
{
static const QHash<QString, QString> map = {
{ "÷", "/" }, { "×", "*" },
};
return map;
}
} // namespace
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
buildUi();
}
void MainWindow::buildUi()
{
auto *central = new QWidget(this);
auto *root = new QVBoxLayout(central);
root->setContentsMargins(12, 12, 12, 12);
root->setSpacing(10);
m_preview = new QLabel(QStringLiteral(" "), central);
m_preview->setObjectName(QStringLiteral("PreviewLabel"));
m_preview->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
m_display = new QLineEdit(central);
m_display->setObjectName(QStringLiteral("DisplayEdit"));
m_display->setReadOnly(true);
m_display->setAlignment(Qt::AlignRight);
m_display->setFont(QFont(QStringLiteral("Menlo"), 22));
// 关键:不让显示框抢焦点,否则数字键会被它吃掉(详见踩坑)
m_display->setFocusPolicy(Qt::NoFocus);
root->addWidget(m_preview);
root->addWidget(m_display);
m_grid = new QGridLayout;
m_grid->setSpacing(6);
for (const KeySpec &spec : kKeys)
makeButton(QString::fromUtf8(spec.face), spec.row, spec.col);
makeButton(QStringLiteral("="), 5, 0, 1, 4);
root->addLayout(m_grid);
setCentralWidget(central);
setWindowTitle(QStringLiteral("计算器"));
resize(320, 460);
statusBar()->showMessage(QStringLiteral("键盘:数字/运算符输入,Enter 求值,Esc 清空,Backspace 退格"));
setFocus();
}
QPushButton *MainWindow::makeButton(const QString &text, int row, int col,
int rowSpan, int colSpan)
{
auto *btn = new QPushButton(text, this);
btn->setObjectName(text == QStringLiteral("=")
? QStringLiteral("EqualButton")
: QStringLiteral("CalcButton"));
btn->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
btn->setMinimumSize(56, 44);
m_grid->addWidget(btn, row, col, rowSpan, colSpan);
connect(btn, &QPushButton::clicked, this, [this, btn] {
handleKey(btn->text());
});
return btn;
}
void MainWindow::handleKey(const QString &face)
{
if (face == QStringLiteral("C")) { clearAll(); return; }
if (face == QStringLiteral("⌫")) { backspace(); return; }
if (face == QStringLiteral("±")) { toggleSign(); return; }
if (face == QStringLiteral("=")) { calculate(); return; }
insert(faceToToken().value(face, face));
}
void MainWindow::insert(const QString &piece)
{
if (m_display->text().startsWith(QStringLiteral("错误")))
m_display->clear();
m_display->setText(m_display->text() + piece);
refreshPreview();
}
void MainWindow::backspace()
{
QString text = m_display->text();
if (text.isEmpty()) return;
text.chop(1);
m_display->setText(text);
refreshPreview();
}
void MainWindow::clearAll()
{
m_display->clear();
m_preview->setText(QStringLiteral(" "));
}
void MainWindow::toggleSign()
{
const QString text = m_display->text();
if (text.isEmpty()) return;
if (text.startsWith(QStringLiteral("-(")) && text.endsWith(')'))
m_display->setText(text.mid(2, text.size() - 3));
else
m_display->setText(QStringLiteral("-(") + text + QStringLiteral(")"));
refreshPreview();
}
void MainWindow::calculate()
{
const QString expr = m_display->text();
if (expr.isEmpty()) return;
const Expression::Result r = Expression::evaluate(expr);
if (!r.ok) {
m_display->setText(QStringLiteral("错误"));
m_preview->setText(r.error);
return;
}
m_preview->setText(expr + QStringLiteral(" ="));
m_display->setText(formatNumber(r.value));
}
void MainWindow::refreshPreview()
{
const QString expr = m_display->text();
if (expr.isEmpty()) { m_preview->setText(QStringLiteral(" ")); return; }
const Expression::Result r = Expression::evaluate(expr);
// 输入过程中表达式多半是残缺的,算不出来就安静地什么都不显示
m_preview->setText(r.ok ? QStringLiteral("= ") + formatNumber(r.value)
: QStringLiteral(" "));
}
QString MainWindow::formatNumber(double v) const
{
if (std::isnan(v) || std::isinf(v)) return QStringLiteral("错误");
if (std::fabs(v - std::round(v)) < 1e-10 && std::fabs(v) < 1e15)
return QString::number(static_cast<qint64>(v)); // 整数不要显示成 8.0
return QString::number(v, 'g', 12);
}
void MainWindow::keyPressEvent(QKeyEvent *event)
{
switch (event->key()) {
case Qt::Key_Return:
case Qt::Key_Enter: handleKey(QStringLiteral("=")); return;
case Qt::Key_Backspace: handleKey(QStringLiteral("⌫")); return;
case Qt::Key_Escape: handleKey(QStringLiteral("C")); return;
default: break;
}
const QString t = event->text();
if (!t.isEmpty() && QStringLiteral("0123456789.+-*/%^()").contains(t.at(0))) {
handleKey(QString(t.at(0)));
return;
}
QMainWindow::keyPressEvent(event); // 交给基类处理 Tab 等按键
}#QSS 美化:一份样式换一套皮肤
样式不在每个控件上 setStyleSheet,而是统一在 QApplication 上设一次。用 setObjectName 给控件起名字,再用 类型#名字 的选择器精确命中,比 QPushButton { ... } 这种一刀切安全得多。
// src/main.cpp
#include <QApplication>
#include "mainwindow.h"
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
app.setStyle(QStringLiteral("Fusion")); // 各平台外观统一,QSS 效果可预期
const QString qss = R"(
QWidget { background: #1e1e24; color: #f2f2f2;
font-family: "PingFang SC", "Microsoft YaHei"; }
QLabel#PreviewLabel { color: #8a8a99; font-size: 13px; padding-right: 6px; }
QLineEdit#DisplayEdit { background: #141418; border: none; border-radius: 8px;
padding: 10px 12px; }
QPushButton#CalcButton { background: #2c2c35; border: none; border-radius: 8px;
font-size: 17px; min-width: 56px; min-height: 44px; }
QPushButton#CalcButton:hover { background: #3a3a46; }
QPushButton#CalcButton:pressed { background: #4a90d9; }
QPushButton#EqualButton { background: #4a90d9; border: none; border-radius: 8px;
font-size: 19px; font-weight: bold; min-height: 48px; }
QPushButton#EqualButton:pressed { background: #3a7fc0; }
QStatusBar { color: #8a8a99; }
)";
app.setStyleSheet(qss);
MainWindow w;
w.show();
return app.exec();
}#关键细节与踩坑
1. 焦点被 QLineEdit 吃掉,键盘失灵。 这是本案例最容易卡住的地方。Qt 的按键事件先发给当前有焦点的控件,只有它不处理才逐级往上抛。显示框是 QLineEdit,默认可获焦,数字键会被它吞掉(只读状态下既不显示也不上报)。解决办法是 m_display->setFocusPolicy(Qt::NoFocus),并在 buildUi 末尾 setFocus() 把焦点交给主窗口。更彻底的做法是给显示框装 eventFilter,或在 QShortcut 里逐个绑定按键。
2. 除零不能用 == 0.0 判断。 浮点运算会有 0.1 * 3 - 0.3 == 5.5e-17 这种结果,直接判等会漏判,也会把本该非零的数误判成零。用 qFuzzyIsNull(rhs)(内部是与 1e-12 量级的比较),这是 Qt 提供的标准写法。^ 运算要额外检查 std::isnan,因为 (-8) ^ 0.5 在实数范围内没有结果。
3. 中文与特殊符号的编码。 源码里的 ⌫、±、÷ 都是非 ASCII 字符。Qt 6 默认按 UTF-8 解释 QString 的字符串字面量,GCC/Clang 一般没问题,但 MSVC 在不加 /utf-8 时会按本地代码页(GBK)解析,界面上直接出现乱码。两条保险:CMake 里加 target_compile_options(... /utf-8),写非 ASCII 字面量时统一用 QStringLiteral 或 QString::fromUtf8。
4. Lambda 里捕获了裸指针,对象销毁后崩溃。 connect(btn, &QPushButton::clicked, this, [this, btn]{...}) 里带 this 作为 context 对象,按钮销毁时连接自动断开,这是安全的。但如果写成 [this] 却不带 context 对象,或捕获了已经被 delete 的指针,就会在回调时访问野指针。规则:带界面对象指针的 connect,第三个参数一定要填 context 对象;捕获局部变量时用 QPointer 更保险。
5. 预览刷新不要触发递归。 refreshPreview() 里调用 Expression::evaluate(),而它不修改 m_display,所以不会形成"文本变化 → 预览 → 文本变化"的死循环。一旦哪天改成在 textChanged 信号里刷新预览,就必须用 QSignalBlocker 或者一个 m_updating 标志位打断递归,否则程序会卡死。
#还能怎么扩展
- 历史记录:把每次
=的(表达式, 结果)存进QVector,用↑/↓键回溯,持久化到QSettings(第四篇第 6 章)。 - 连续运算符替换:现在输入
5 * - 3会变成5 * - 3(求值器能正确处理一元负号),但输入5 * + 3时体验不佳。可以在insert()里判断"上一个是运算符且新输入也是运算符"时用后者替换前者,注意排除紧跟(后的一元负号。 - 内存键:加
MC / MR / M+ / M-四个键,用一个double m_memory成员即可,是练状态管理的好素材。 - 科学计算:补
sin / cos / sqrt / log作为函数调用,需要在tokenize里增加"标识符"这一类 token,并把它们当作优先级最高的运算符处理。 - 移植到 QML:
Expression类加Q_INVOKABLE后注册为单例,用GridLayout+Repeater重写界面,你会直观感受到声明式布局比手写循环省多少代码(第五篇第 3 章)。
#小结
- 界面搭建可以"数据化":把按钮的外观、位置、行为放进数组,用循环生成,
addWidget(w, r, c, rs, cs)的第 5、6 个参数用来跨行跨列。 - 输入路径要收敛到单一入口(这里的
handleKey),鼠标和键盘共用一套逻辑,避免两边行为不一致。 - 表达式求值 = 词法分析 + 调度场算法 + 后缀求值三步;一元负号用"补 0"的技巧消解,
expectOperand状态位是关键。 - 浮点比较一律用
qFuzzyIsNull/qFuzzyCompare,不要用==。 - QSS 用
类型#objectName选择器精确定位,并在QApplication上统一设置一次;跨平台先用Fusion风格打底。 - 键盘类界面的第一号坑是焦点:确认目标控件没被可获焦的子控件挡住。
#练习
- 增加
MC / MR / M+ / M-四个内存键(第五行左侧插入一列,网格改为 6×4),用一个double成员保存记忆值,并在状态栏显示当前记忆值。 - 实现表达式历史:每次
=成功后把"表达式 = 结果"追加到一个QListWidget(停靠在窗口右侧,默认隐藏,按Ctrl+H切换显示),点击历史项把它填回显示框。 - 让预览支持"残缺表达式":输入
3 +时预览显示上一次有效结果而不是留空,需要在MainWindow里缓存最近一次成功的Expression::Result。 - 给
Expression写一个基于QtTest的单元测试(第二篇第 5 章),至少覆盖:优先级2+3*4=14、右结合2^3^2=512、一元负号-3^2=-9、除零报错、括号不匹配报错。