QC++ / Qt 学习之路

案例:计算器(布局与信号槽的综合练习)

用 QGridLayout 搭按钮阵列,手写表达式求值器,练布局与信号槽

实战第 42 / 48 章第六篇 · 案例实战

#这个案例做什么

从一个空白窗口开始,手写一个能算 3 + 4 * (2 - 1) ^ 2 的桌面计算器:不用 Designer 拖控件,全部代码搭界面;不用 QJSEngine 偷懒,自己实现一个表达式求值器;不用鼠标也能算,键盘直接敲。它是第六篇的开胃菜——代码量不大,但布局、信号槽、事件、字符串处理、样式表一次全用上,是检验前五篇基本功的最好方式。

计算器 · Qt Widgets 文件 编辑 查看 帮助 1,024.00 C ÷ × ⌫ 7 8 9 − 4 5 6 + 1 2 3 = 0 . ± 标准模式 · 支持键盘 0-9 输入 MCalc QLabel · 右对齐 QPushButton × 19 QGridLayout
计算器界面结构——顶部表达式显示区 + 5×4 按钮阵列与底部等号键

功能清单:

  • 支持 + - * / % ^ 六种运算符、小括号、一元负号,正确处理优先级与结合性;
  • 点击按钮或敲键盘输入表达式,输入过程中实时预览当前结果;
  • 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 章 工程化

#项目结构

Text
calculator/
├── CMakeLists.txt
└── src/
    ├── main.cpp            # 程序入口 + 全局 QSS
    ├── mainwindow.h
    ├── mainwindow.cpp      # 界面搭建、按钮连接、键盘输入
    ├── expression.h
    └── expression.cpp      # 与界面完全无关的求值器

把求值器放在独立文件里,是本篇反复强调的习惯:算法与界面解耦。这样 expression.cpp 可以单独写单元测试,换 QML 界面时一行都不用改。

CMake
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 界面类。

C++
// 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,后面就不需要任何特殊处理了。

C++
// 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 里最常用的界面生成套路。

C++
// 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 是唯一的动作入口,参数是按钮表面文字。按钮点击和键盘输入都转成这个字符串再分发,两条输入路径共用一套逻辑,不会走着走着就分叉。

C++
// 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 { ... } 这种一刀切安全得多。

C++
// 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 风格打底。
  • 键盘类界面的第一号坑是焦点:确认目标控件没被可获焦的子控件挡住。

#练习

  1. 增加 MC / MR / M+ / M- 四个内存键(第五行左侧插入一列,网格改为 6×4),用一个 double 成员保存记忆值,并在状态栏显示当前记忆值。
  2. 实现表达式历史:每次 = 成功后把 "表达式 = 结果" 追加到一个 QListWidget(停靠在窗口右侧,默认隐藏,按 Ctrl+H 切换显示),点击历史项把它填回显示框。
  3. 让预览支持"残缺表达式":输入 3 + 时预览显示上一次有效结果而不是留空,需要在 MainWindow 里缓存最近一次成功的 Expression::Result。
  4. 给 Expression 写一个基于 QtTest 的单元测试(第二篇第 5 章),至少覆盖:优先级 2+3*4=14、右结合 2^3^2=512、一元负号 -3^2=-9、除零报错、括号不匹配报错。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。