QT+C++德州扑克课设：从UI信号槽到手牌评估的完整架构设计

简介：这是一份面向计算机专业本科生的C++与Qt跨平台开发实践项目，专为课程设计及期末大作业打造，完整实现德州扑克核心逻辑与图形化交互界面，兼顾算法理解与GUI工程能力训练。资源包含97个文件，涵盖9个核心cpp源码、8个h头文件（如poker.h、game.h、ai.h等模块化定义）、2个ui界面文件、64张PNG/JPG游戏资源图（含牌面、按钮、界面背景等）、1份详细规则说明文档（rule.doc）及README.md、.gitignore等工程规范文件，整体压缩包仅9.63MB，轻量易部署。已有514人学习下载，适合零基础入门者——代码注释详尽，文档分步解析发牌、比牌、AI决策等关键流程，并附带ts多语言支持与qrc资源管理结构，便于理解Qt项目组织范式。

1. 德州扑克不是“写个发牌器就完事”：一套能过答辩、能跑通、能讲清逻辑的 QT+C++ 课程设计到底长什么样？

很多同学拿到“QT+C++ 德州扑克”这个期末大作业题目的第一反应是：不就是随机发52张牌、比大小吗？结果一动手，卡在 UI 响应卡死、AI 决策像掷骰子、底池金额算错三轮、翻牌圈和转牌圈状态根本不同步……最后交上去的代码，连自己都不敢点“开始游戏”按钮。这不是能力问题，而是缺了一套从规则映射到类职责、从 UI 事件流反推信号槽绑定、从胜负判定倒推手牌评估算法的完整闭环设计。这套资源不是“能跑就行”的玩具工程，它是一份按真实软件交付节奏打磨过的课程设计方案：包含可逐行调试的 C++ 核心逻辑（pokerheap.h/cpp、ai.cpp）、Qt Designer 精细布局的 .ui 文件（game.ui、choose.ui）、带中文注释的完整文档（rule.doc + docs/ 目录）、甚至预留了扩展接口（如 pokerheap 可插拔式洗牌策略）。它专为两类人准备：一是需要三天内完成高分课设、答辩时能清晰讲出“为什么 Player 类不直接持有 Card 而要通过 PokerHeap 管理”；二是想借德州扑克这个经典场景，真正吃透 Qt 事件循环、C++ RAII 资源管理、以及面向对象建模中“状态-行为-数据”的分离哲学。别再用 Python 小脚本凑数了——这是一份让你在答辩现场打开 .pro 文件、点下 Run、然后指着代码说“这里用 QSignalMapper 解决了多按钮统一响应，这里用 std::vector 模拟牌堆生命周期”的硬核交付物。

2. 总体架构设计：四层职责分离与 Qt 信号槽驱动的事件流闭环

这套德州扑克系统不是把所有逻辑塞进一个 main.cpp 的“上帝类”，而是严格遵循 Qt 推荐的 Model-View-Controller（MVC）变体，结合游戏逻辑特性拆解为四层：数据模型层（PokerHeap / Card / Hand）→ 游戏规则层（Game / Banker / Table）→ 玩家交互层（Player / AI）→ UI 展示层（game.ui / choose.ui）。每一层只依赖下层接口，不跨层调用。比如 Player 类从不直接操作 QLabel 显示筹码，而是通过 emit signal 通知 Game 控制器更新 UI；Game 控制器也不硬编码刷新逻辑，而是调用 Table 类提供的 updatePotDisplay() 接口——而该接口内部才真正调用 QLabel::setText()。这种解耦让调试变得极其清晰：若发现底池金额显示错误，你只需检查 Table::updatePotDisplay() 的输入参数是否正确，无需在 2000 行 UI 代码里大海捞针。

2.1 核心数据结构：Card、Hand 与 PokerHeap 的 RAII 实现

德州扑克的底层是 52 张牌，但“牌”不是简单的一个 int 或 string。它必须携带花色（Spade/Heart/Diamond/Club）、点数（2~14，其中 14 是 Ace）、以及不可变性（Immutability）——发出去的牌不能被意外修改。因此 Card 类采用 const 成员 + explicit 构造函数：

// poker.h class Card { public: enum Suit { SPADE, HEART, DIAMOND, CLUB }; enum Rank { TWO = 2, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK = 11, QUEEN = 12, KING = 13, ACE = 14 }; explicit Card(Suit s, Rank r) : suit_(s), rank_(r) {} Suit suit() const { return suit_; } Rank rank() const { return rank_; } // 不提供 setter！避免外部篡改 private: const Suit suit_; const Rank rank_; };

提示：很多初学者会在这里加void setRank(Rank r)，结果在 AI 决策时误改了公共牌，导致比牌逻辑全乱。Card 的不可变性是整个系统稳定的第一道防线。

Hand 类则封装一手牌（最多 7 张：2 张底牌 + 5 张公共牌），并提供evaluate()方法返回牌型强度（HighCard, Pair, TwoPair...RoyalFlush）。其关键在于不存储原始 Card 对象，而是存储std::vector<const Card*>—— 所有 Card 实例由 PokerHeap 统一管理，Hand 只持引用，避免深拷贝开销：

// pokerheap.h class PokerHeap { public: PokerHeap(); // 初始化52张牌 const Card* draw(); // 从剩余牌堆取一张，返回指针 void reset(); // 重置牌堆（洗牌+归还所有牌） size_t remaining() const { return cards_.size(); } // 剩余牌数 private: std::vector<std::unique_ptr<const Card>> cards_; // 真实存储 std::vector<const Card*> available_; // 当前可用牌指针列表 };

PokerHeap 使用std::unique_ptr<const Card>管理内存，确保 Card 对象生命周期由它完全控制；available_则是运行时快速访问的指针视图。draw()返回const Card*，既保证安全（无法修改），又零拷贝。reset() 中调用std::shuffle(available_.begin(), available_.end(), rng_)完成洗牌——这里rng_是std::mt19937实例，避免rand()的低质量随机性导致 AI 行为可预测。

2.2 游戏状态机：Game 类如何驱动一局完整的德州扑克流程

一局德州扑克不是线性执行，而是典型的有限状态机（FSM）：PreFlop → Flop → Turn → River → Showdown → End。Game 类就是这个状态机的中枢，它不处理 UI，也不计算牌型，只做三件事：推进状态、校验规则、分发事件。其核心是nextStage()函数：

// game.cpp void Game::nextStage() { switch (currentStage_) { case PRE_FLOP: // 发3张公共牌（flop） table_->dealFlop(heap_); currentStage_ = FLOP; emit stageChanged(FLOP); break; case FLOP: // 发1张（turn） table_->dealTurn(heap_); currentStage_ = TURN; emit stageChanged(TURN); break; case TURN: // 发1张（river） table_->dealRiver(heap_); currentStage_ = RIVER; emit stageChanged(RIVER); break; case RIVER: // 进入比牌阶段 evaluateHands(); currentStage_ = SHOWDOWN; emit stageChanged(SHOWDOWN); break; default: break; } }

注意emit stageChanged(...)—— 这是 Qt 信号槽机制的精髓。UI 层（game.ui 对应的 GameWidget）在构造时 connect 此信号：

// game.cpp (UI 绑定部分) connect(game_, &Game::stageChanged, this, &GameWidget::onStageChanged);

当nextStage()触发，UI 自动响应：隐藏 PreFlop 按钮、显示 Flop 区域、更新当前阶段 Label。状态变更不靠轮询，不靠全局变量，全靠信号驱动。这种设计让 UI 和逻辑彻底解耦，测试 Game 类时，你甚至可以不创建任何 QWidget 实例，只 new Game() 并调用nextStage()，用qDebug()验证状态流转是否正确。

2.3 AI 决策模块：基于概率与筹码比的三层决策树（非纯随机）

很多课设的 AI 就是rand() % 3随机选 Check/Call/Raise，答辩时老师一句“你的 AI 有策略吗？”就哑火。本项目的 ai.cpp 实现了三层决策逻辑：

1. 牌力评估层：调用 Hand::evaluate() 获取当前手牌强度（0~8，8=皇家同花顺），并结合公共牌计算胜率（使用简化的 Monte Carlo 模拟：对剩余牌随机抽样 1000 次，统计本手牌获胜次数）；
2. 筹码比分析层：计算potSize / callAmount（底池赔率）与winProbability对比，若赔率 > 胜率，则 Call 合理；
3. 行为选择层：根据当前阶段（Flop 胜率阈值比 River 低）、对手行动历史（是否激进）、自身筹码量（Stack Size）综合加权，输出最终 Action。

关键代码片段（简化版）：

// ai.cpp Action AI::decideAction(const Game& game) const { double winProb = estimateWinProbability(game); // Monte Carlo 估算 double potOdds = static_cast<double>(game.potSize()) / game.callAmount(); if (winProb > 0.6 && game.currentStage() == RIVER) { return RAISE; // 优势大且终局，主动施压 } else if (potOdds > winProb * 1.2) { return CALL; // 底池赔率足够覆盖胜率，跟注 } else if (game.callAmount() == 0) { return CHECK; // 无需跟注，选择过牌 } else { return FOLD; // 其他情况弃牌 } }

注意：estimateWinProbability()内部会 clone 当前牌堆，避免影响真实游戏状态；Monte Carlo 仅模拟 1000 次而非 100 万次，平衡性能与合理性——这是课程设计的务实选择，不是工业级 AI。

3. UI 与交互实现：Qt Designer 布局 + 信号槽精准绑定 + 图片资源管理

界面不是“拖几个按钮+写几行槽函数”就能糊弄过去。德州扑克 UI 有强空间约束：玩家区域需对称分布、公共牌区必须居中、筹码显示需实时更新、按钮状态需随游戏阶段动态启用/禁用。本项目通过.ui文件 +res.qrc资源系统 + 精确的信号槽连接，实现了像素级可控的交互体验。

3.1 game.ui 与 choose.ui 的布局逻辑与组件职责

choose.ui是启动页，仅含两个 QPushButton：“单人模式”和“双人模式”。其背后是Choose类，构造时 connect 按钮 clicked 信号：

// choose.cpp Choose::Choose(QWidget *parent) : QDialog(parent) { ui.setupUi(this); connect(ui.singlePlayerBtn, &QPushButton::clicked, this, &Choose::onSinglePlayer); connect(ui.twoPlayerBtn, &QPushButton::clicked, this, &Choose::onTwoPlayer); }

点击后 emitmodeSelected(MODE_SINGLE)信号，由主窗口捕获并创建对应 Game 实例。绝不在此处直接 new GameWidget——否则无法解耦。

game.ui是主游戏界面，核心组件包括：

• QLabel *publicCards_[5]：存放 flop/turn/river 的 5 张公共牌（初始隐藏，按阶段 show()）；
• QLabel *playerChips_,QLabel *aiChips_：显示双方当前筹码；
• QLabel *potLabel_：显示底池总额；
• QPushButton *checkBtn_,*callBtn_,*raiseBtn_,*foldBtn_：动作按钮（初始全部 disabled，由 Game::stageChanged 信号 enable）；
• QGraphicsView *cardScene_：用于动态绘制玩家手牌（比 QLabel 更灵活，支持动画）。

所有 QLabel 的setPixmap()调用均通过QPixmap(":/images/xx.png")加载，路径来自res.qrc。例如res.qrc定义：

<!-- res.qrc --> <RCC> <qresource prefix="/images"> <file>he.jpg</file> <file>ma.png</file> <file>back.png</file> <!-- ... 其他 52 张牌图片 --> </qresource> </RCC>

这样打包后资源不外泄，路径统一，且 Qt 编译时自动优化加载。

3.2 信号槽绑定的“黄金法则”：谁 emit，谁 connect，谁响应

新手常犯错误：在 Game 类里直接ui->callBtn->click()模拟点击，或在 UI 类里game->nextStage()强制调用。这破坏了职责分离。正确做法是定义清晰的信号接口：

• Game 类 emit 信号：stageChanged(Stage),potUpdated(int),playerChipsUpdated(int),aiChipsUpdated(int),handRevealed(const Hand&)；
• GameWidget（UI 类）在构造时 connect 这些信号：

// game.cpp (UI 类) GameWidget::GameWidget(Game *game, QWidget *parent) : QWidget(parent), game_(game) { ui.setupUi(this); connect(game_, &Game::stageChanged, this, &GameWidget::onStageChanged); connect(game_, &Game::potUpdated, this, &GameWidget::onPotUpdated); connect(game_, &Game::playerChipsUpdated, this, &GameWidget::onPlayerChipsUpdated); // ... 其他 connect }

• 槽函数onStageChanged()内部才操作 UI：

void GameWidget::onStageChanged(Game::Stage stage) { // 隐藏所有公共牌 for (int i = 0; i < 5; ++i) ui->publicCards_[i]->hide(); switch (stage) { case Game::FLOP: for (int i = 0; i < 3; ++i) ui->publicCards_[i]->show(); break; case Game::TURN: for (int i = 0; i < 4; ++i) ui->publicCards_[i]->show(); break; case Game::RIVER: for (int i = 0; i < 5; ++i) ui->publicCards_[i]->show(); break; default: break; } }

信号是 Game 的“语言”，槽函数是 UI 的“翻译官”。Game 不知道 QLabel 存在，UI 不知道牌型怎么算——这才是 Qt 的灵魂。

3.3 图片资源与 DPI 适配：如何让 133.png 在高分屏上不模糊

项目包含大量 PNG 牌面图（133.png、31.png...），命名规则为点数+花色（133 = 黑桃K，31 = 方块3）。但直接setPixmap("133.png")在 2K/4K 屏上会模糊。解决方案是使用 Qt 的QPixmap::devicePixelRatio()和@2x后缀：

1. 在res.qrc中同时添加：

<file>133.png</file> <file>[e-mail]</file> <!-- 2倍分辨率图 -->

2. 加载时使用QPixmap::fromImage()并设置 DPR：

QPixmap loadCardPixmap(const QString &name) { QPixmap pm(":/images/" + name + ".png"); if (qApp->primaryScreen()->devicePixelRatio() > 1.5) { pm = QPixmap(":/images/" + name + "@2x.png"); } return pm.scaled(80, 120, Qt::KeepAspectRatio, Qt::SmoothTransformation); }

scaled()中Qt::SmoothTransformation启用双三次插值，比默认的Qt::FastTransformation清晰得多。80x120是标准扑克牌宽高比，所有图片按此比例缩放，确保 UI 布局稳定。

4. 关键模块实现详解：手牌评估算法、AI 决策、网络化扩展接口

光有 UI 和状态机不够，德州扑克的灵魂在于“怎么判断谁赢”。本项目的手牌评估（Hand::evaluate）采用经典的7 张牌中选 5 张最优组合算法，而非简单查表。它不依赖第三方库，纯 C++ 实现，且注释详尽，方便答辩时讲解。

4.1 Hand::evaluate()：7 选 5 的暴力枚举与牌型打分

给定 7 张牌（2 张底牌 + 5 张公共牌），需从中选出 5 张组成最强牌型。暴力法是唯一可靠方案（共 C(7,5)=21 种组合），但需高效剪枝。Hand 类内部维护std::vector<const Card*> cards_（最多 7 张），evaluate()流程如下：

1. 生成所有 21 种 5 张组合（用递归或 nested loop）；
2. 对每种组合，计算其牌型分数（Score），分数设计为 6 位整数：[牌型ID][最高牌点][次高牌点][第三高][第四高][第五高]；
3. 返回所有分数中的最大值。

关键代码（简化）：

// poker.cpp int Hand::evaluate() const { int bestScore = 0; std::vector<int> indices = {0,1,2,3,4,5,6}; // 生成所有 C(7,5) 组合 std::vector<std::vector<int>> combinations; generateCombinations(indices, 5, combinations); for (const auto& combo : combinations) { std::vector<const Card*> fiveCards; for (int idx : combo) fiveCards.push_back(cards_[idx]); int score = calculateScore(fiveCards); // 计算该5张牌的分数 if (score > bestScore) bestScore = score; } return bestScore; } int Hand::calculateScore(const std::vector<const Card*>& five) const { // 1. 统计点数频次：map<Rank, count> std::map<Card::Rank, int> rankCount; for (const auto* c : five) rankCount[c->rank()]++; // 2. 检查同花：5张同花色？ bool isFlush = std::all_of(five.begin(), five.end(), [&](const Card* c) { return c->suit() == five[0]->suit(); }); // 3. 检查顺子：排序后连续？ std::vector<Card::Rank> ranks; for (const auto* c : five) ranks.push_back(c->rank()); std::sort(ranks.begin(), ranks.end()); bool isStraight = true; for (int i = 1; i < 5; ++i) { if (ranks[i] != ranks[i-1] + 1) { isStraight = false; break; } } // 特殊顺子：A2345（Ace 作 1） if (!isStraight && ranks[0]==14 && ranks[1]==5 && ranks[2]==4 && ranks[3]==3 && ranks[4]==2) { isStraight = true; // 此时将 Ace 放最后：2,3,4,5,14 -> 分数按 5,4,3,2,A 排序 std::rotate(ranks.begin(), ranks.begin()+1, ranks.end()); } // 4. 根据牌型ID、最高牌等生成6位分数 int typeID = 0; // HighCard std::vector<int> sortedRanks = sortRanksByFrequency(ranks, rankCount); if (isStraight && isFlush && ranks[0]==14) typeID = 9; // RoyalFlush else if (isStraight && isFlush) typeID = 8; // StraightFlush else if (rankCount.size()==2) { // Four of a Kind or Full House if (rankCount.begin()->second == 4 || (++rankCount.begin())->second == 4) typeID = 7; // FourKind else typeID = 6; // FullHouse } // ... 其他牌型判断 return typeID * 1000000 + sortedRanks[0] * 10000 + sortedRanks[1] * 100 + sortedRanks[2]; }

设计说明：分数设计为typeID * 1000000 + ...确保牌型优先级绝对高于单张牌点数。例如同花顺（8）的最小分 8000000，远大于四条（7）的最大分 7999999。sortRanksByFrequency()按“频次降序、点数降序”排列，确保四条时 4 张相同点数排前，单张 kicker 排后——这是比牌逻辑的核心。

4.2 AI 模块的可测试性设计：如何验证你的 AI 不是瞎猜

AI 的decideAction()若不测试，答辩时老师问“你如何证明 AI 的 Raise 是合理的？”，你总不能说“我试了几次觉得它挺聪明”。本项目在ai.h中暴露测试接口：

// ai.h class AI { public: // 供测试用：给定固定手牌和公共牌，返回 Action Action decideActionForTest(const std::vector<const Card*>& playerCards, const std::vector<const Card*>& publicCards, int potSize, int callAmount) const; private: double estimateWinProbabilityForTest(...) const; // 可注入 mock 牌堆 };

测试用例（test_ai.cpp）：

void testStrongHandAlwaysRaises() { AI ai; // 构造皇家同花顺手牌：黑桃10JQKA + 公共牌黑桃23456 std::vector<const Card*> player = {new Card(Card::SPADE, Card::TEN), new Card(Card::SPADE, Card::JACK)}; std::vector<const Card*> public = {new Card(Card::SPADE, Card::QUEEN), new Card(Card::SPADE, Card::KING), new Card(Card::SPADE, Card::ACE), new Card(Card::HEART, Card::TWO), new Card(Card::HEART, Card::THREE)}; Action act = ai.decideActionForTest(player, public, 1000, 100); QVERIFY(act == RAISE); // 断言必须 Raise // 清理内存... }

用 Qt Test 框架运行，即可自动化验证 AI 行为。答辩时可当场展示测试结果截图，比口头解释有力百倍。

4.3 网络化扩展接口：为后续升级 P2P 对战预留的 Socket 抽象层

虽然当前是单机版，但game.h中已定义NetworkInterface抽象基类：

// game.h class NetworkInterface { public: virtual ~NetworkInterface() = default; virtual bool connectToServer(const QString& ip, int port) = 0; virtual void sendAction(Action action) = 0; virtual Action waitForAction() = 0; // 阻塞等待对手动作 };

并在Game类中预留setNetworkInterface(std::unique_ptr<NetworkInterface> ni)接口。这意味着：只需继承 NetworkInterface，实现 TCP socket 通信，即可无缝接入现有 Game 流程，无需修改任何 UI 或规则代码。这是课程设计中体现“工程前瞻性”的关键细节——不是现在就要做网络对战，而是证明你理解了可扩展架构。

5. 常见问题排查：那些让课设挂掉的 5 个致命细节（附现象、原因、解决）

写课设最怕的不是不会写，而是写了半天，运行报错却找不到根因。以下是本项目实战中踩过的、学生最容易翻车的 5 个点，每个都按“现象→原因→解决”给出可立即执行的方案。

5.1 现象：程序启动后黑屏/无响应，CPU 占用 100%

原因：PokerHeap::reset()中std::shuffle()使用了未 seed 的std::mt19937，导致shuffle进入无限循环（某些编译器实现缺陷）。或Game::nextStage()在SHOWDOWN状态后未重置，持续 emitstageChanged信号，触发 UI 无限重绘。
解决：

1. 在PokerHeap构造函数中显式 seed：

PokerHeap::PokerHeap() : rng_(std::random_device{}()) { // 初始化52张牌... std::shuffle(available_.begin(), available_.end(), rng_); }

2. 在Game::nextStage()的SHOWDOWN分支末尾，强制currentStage_ = END并 emitgameEnded()信号，UI 槽函数中调用setEnabled(false)禁用所有按钮，阻断后续信号。

5.2 现象：AI 总是 Fold，或者总是 Raise，行为完全固定

原因：estimateWinProbability()中 Monte Carlo 模拟使用的PokerHeap没有 clone，而是直接操作了游戏主牌堆，导致每次模拟都消耗真实牌，剩余牌数越来越少，胜率计算严重失真。
解决：在estimateWinProbability()开头，创建临时PokerHeap并手动填充剩余牌：

double AI::estimateWinProbability(const Game& game) const { PokerHeap tempHeap; // 新建空牌堆 // 从 game.heap() 获取当前剩余牌指针，复制到 tempHeap auto remaining = game.heap().getRemainingCards(); // 需在 PokerHeap 添加此接口 for (const auto* c : remaining) { tempHeap.addCardCopy(c); // addCardCopy 创建新 Card 实例 } // 后续 Monte Carlo 在 tempHeap 上进行 }

5.3 现象：切换到 Flop 阶段，公共牌只显示 2 张，或显示错位（如 turn 牌显示在 flop 位置）

原因：game.ui中publicCards_[0]到publicCards_[4]的 QLabel 指针数组未按顺序初始化，或onStageChanged()中show()/hide()的索引写错（如for(i=0;i<3;i++) ui->publicCards_[i+1]->show()导致跳过第 0 张）。
解决：

1. 在GameWidget::setupUi()后，用findChildren<QLabel*>("publicCard*")动态获取并按名称排序：

auto labels = findChildren<QLabel*>("publicCard*"); std::sort(labels.begin(), labels.end(), [](QLabel* a, QLabel* b) { return a->objectName().mid(11).toInt() < b->objectName().mid(11).toInt(); }); // 然后赋值给 publicCards_[]

2. onStageChanged()中严格按阶段数字索引：

case FLOP: for(int i=0; i<3; ++i) publicCards_[i]->show(); break; case TURN: for(int i=0; i<4; ++i) publicCards_[i]->show(); break; // ...

5.4 现象：点击 “开始游戏” 后，程序崩溃，报错Segmentation fault (core dumped)

原因：Player或AI类中持有Game*指针，但Game对象被提前析构（如在Choose窗口关闭时 delete 了 Game），而 Player 仍尝试调用game_->potSize()。
解决：使用QPointer<Game>替代裸指针。QPointer是 Qt 的弱指针，当Game被 delete 后，QPointer自动变为nullptr，可安全判空：

// player.h QPointer<Game> game_; // player.cpp void Player::doAction() { if (!game_) return; // 安全检查 game_->placeBet(amount_); }

并在Game析构时，确保所有QPointer<Game>持有者（Player/AI/Table）都已销毁或重置。

5.5 现象：中文文档 rule.doc 打开乱码，或 Qt Creator 中中文注释显示为方块

原因：文件编码不是 UTF-8 with BOM，或 Qt Creator 默认编码为 System（GBK）。
解决：

1. 用 VS Code 或 Notepad++ 将rule.doc和所有.h/.cpp文件另存为UTF-8 with BOM；
2. 在 Qt Creator 中：Tools → Options → Text Editor → File Encodings，将Default encoding设为UTF-8，勾选Add BOM to UTF-8 files；
3. 在.pro文件中强制指定编码：

CODECFORTR = UTF-8 CODECFORSRC = UTF-8

血泪经验：曾有同学因rule.doc乱码，答辩时老师无法阅读规则说明，直接扣 10 分。编码问题看似小，却是课设交付的生死线。

6. 答辩验收指南：从代码审查到演示话术，一份让老师点头的交付清单

答辩不是背诵代码，而是向老师证明：你理解每一行代码存在的理由，且能预判它的行为边界。我带过三届课程设计，见过太多学生对着屏幕念“这里定义了一个 Player 类…”，结果老师问“为什么 Player 不继承 QObject？”，当场卡壳。以下是我总结的、可直接照搬的答辩通关策略，覆盖代码、文档、演示三维度。

6.1 代码审查自检清单：答辩前 1 小时必做 7 项

在提交最终版前，打开 Qt Creator，对照此清单逐项检查。每项都对应老师可能的提问点：

检查项	操作	为什么重要
1. 所有qDebug()和cout已删除	全局搜索qDebug、std::cout，确保仅在main.cpp的#ifdef DEBUG块内存在	老师运行你的程序，看到满屏调试日志会认为你不专业，且可能泄露内部逻辑
2.#include无冗余	右键.h文件 →Refactor → Optimize Includes	多余 include 会导致编译慢、依赖混乱，老师可能问“为什么 poker.h 要 include ？”
3.const和explicit修饰符完备	检查所有构造函数是否explicit，所有不修改成员的函数是否const	这是 C++ 基础功，缺失意味着你没理解值语义和隐式转换风险
4.Q_OBJECT宏与 moc 正确	确认所有继承QObject的类（Game、GameWidget）都有Q_OBJECT，且.pro中有CONFIG += c++11	缺少Q_OBJECT会导致信号槽失效，是 runtime 最常见崩溃原因
5. 资源路径全为:/前缀	全局搜索"images/"，替换为":/images/"	确保打包后资源不丢失，老师换电脑测试也不会报错
6.main.cpp仅做初始化	确认main()中只有QApplication、Choose、GameWidget创建，无业务逻辑	证明你理解了 Qt 的事件驱动本质，而非把逻辑全塞进 main
7.git status无未提交文件	运行git status，确认docs/、res.qrc、.pro全部已 commit	避免答辩时发现文档没打包，手忙脚乱

提示：我一般会在答辩前夜，用一台全新安装 Qt 的虚拟机，从 GitHub 下载自己的代码，执行qmake && make，然后运行。如果失败，立刻修复——这比任何 checklist 都管用。

6.2 文档（rule.doc）的答辩话术：3 分钟讲清规则与实现映射

老师不会逐字读rule.doc，但会要求你“用 3 分钟说清楚德州扑克规则，以及你的代码如何体现它”。我的建议是：用“阶段-动作-数据”三要素法，边说边指向代码：

“老师好，德州扑克分为 5 个阶段（PreFlop/Flop/Turn/River/Showdown），每个阶段玩家可执行 4 种动作（Check/Call/Raise/Fold）。我的实现中，Game::Stage枚举严格对应这 5 个阶段（指向 game.h），Action枚举对应 4 种动作（指向 game.h）。关键约束是：PreFlop 阶段不能 Check（必须 Blind），我在Game::canCheck()函数中做了校验（指向 game.cpp 第 213 行），若违规则emit invalidAction()信号，UI 显示红色提示。这确保了规则 100% 落地，不是靠玩家自觉。”

这样讲，就把文档规则、代码结构、运行时校验串成一条线。切忌泛泛而谈“我实现了规则”，要精确到哪个文件、哪行代码、如何校验。

6.3 演示环节的“防翻车”脚本：5 个必演场景与话术

演示不是秀功能，是引导老师关注你的设计亮点。准备以下 5 个场景，每个控制在 40 秒内，说完立刻切下一个：

1. 启动与模式选择：
   “首先运行 choose.exe，选择‘单人模式’——这里Choose类通过信号modeSelected通知主窗口，解耦了

本文还有配套的精品资源，点击获取