C++写的五子棋AI对战程序，带源码、可执行文件和详细课程报告

关注

原创最新推荐文章于 2026-09-26 16:48:47 发布 255 阅读 AI 写同款· GEO 优化 ›

简介：一个开箱即用的C++五子棋AI对弈程序，支持人机对弈和AI自对弈两种模式。程序包含完整可编译源码，所有核心功能模块独立封装：evaluate.cpp负责局面评分，searchmove.cpp实现带Alpha-Beta剪枝的极小化极大搜索算法，makemove.cpp处理落子逻辑，gameover.cpp判断胜负，createmoves.cpp生成合法着法，printchessboard.cpp渲染终端棋盘界面，define.cpp和头文件统一管理常量与接口。main.cpp整合流程，逻辑清晰适合教学理解。配套Word文档《五子棋博弈问题.docx》涵盖设计思路、算法原理（如评估函数构造、剪枝优化效果）、测试对局记录及运行说明。提供已编译的test.exe，Windows下双击即可运行，无需额外环境配置。全部源码含中文注释，变量命名规范，模块职责明确，适用于人工智能导论、算法实践或课程设计项目，帮助学习者掌握博弈树搜索、启发式评估与C++工程化实现。

1. 项目概述：这不是一个“玩具程序”，而是一套可拆解、可验证、可教学的博弈AI最小可行系统

五子棋AI，听起来像是算法课上被反复咀嚼过的经典案例——但绝大多数人接触的，要么是教科书里几行伪代码，要么是GitHub上几百星却注释稀疏、逻辑缠绕的“黑盒”。而眼前这套C++五子棋AI对战程序，我第一次在实验室学生交来的课程设计包里看到时，就立刻把它从“作业堆”里单独拎了出来。它不是为了炫技，也不是为了跑通一个Demo，而是用最朴素的C++语法、最清晰的模块划分、最诚实的注释密度，把博弈智能的核心骨架一层层剥开给你看。关键词里的“五子棋AI”、“C++源码”、“Alpha-Beta剪枝”、“极小化极大”、“局面评估”，在这里不是标签，而是每一个.cpp文件里跳动的函数、每一行注释里写明的意图、每一段测试记录中可复现的性能数据。

它解决的，是一个非常具体、也非常痛的问题：初学者如何真正理解“AI下棋”这件事，而不是只记住“极大极小”四个字？ 你可以在searchmove.cpp里，一行行跟踪alphaBetaSearch()函数如何递归展开博弈树；可以在evaluate.cpp里，亲手修改一个权重系数，然后运行test.exe自对弈10局，看胜率变化；可以在createmoves.cpp里，对比“暴力生成所有空位”和“基于活三/冲四启发式筛选”的候选着法数量差异——这些都不是理论推演，而是敲下回车键后立刻反馈到终端上的真实世界。它适合谁？如果你是刚学完《数据结构》、正要啃《人工智能导论》的学生，它就是你的第一块“可触摸的AI积木”；如果你是带课老师，它就是一份无需二次加工、学生能直接读懂、改得明白、测得清楚的完整教学素材；如果你是想补足工程能力的算法爱好者，它示范了如何把一个抽象算法，落地为有头文件、有编译规则、有明确输入输出、有错误处理的C++工程。它不追求击败职业棋手，它的目标很务实：让你在Windows双击test.exe的那一刻，看到一个黑白分明的棋盘，输入坐标，AI落子，胜负立判，并且你知道，这背后每一步，都源于你刚刚在main.cpp里读过的那十几行主循环逻辑。

2. 整体架构与设计思路：为什么是“模块化”而非“一体化”？

这套程序最值得称道的地方，不是它用了Alpha-Beta剪枝，而是它用一种近乎“教科书式”的克制，把整个博弈系统拆解成了七个职责单一、接口清晰、彼此解耦的模块。这种设计绝非炫技，而是直指教学与工程实践的核心痛点：可理解性、可调试性、可替换性。我们来拆解一下这个“七巧板”是如何拼出完整AI的。

2.1 模块划分的底层逻辑：从“问题域”到“代码域”的精准映射

首先，必须明确一点：五子棋AI的本质，是一个状态空间搜索问题。它由四个不可分割的原子操作构成：表示状态（棋盘）、生成动作（合法着法）、评估状态（局面好坏）、选择动作（搜索决策）。这套程序的模块划分，正是对这四个原子操作的直接映射，并额外增加了支撑模块（定义、渲染、主控）。来看这张核心职责对照表：

模块文件	核心职责	对应的AI原子操作	为什么必须独立？
`define.h/.cpp`	统一管理全局常量（如棋盘大小`BOARD_SIZE=15`）、枚举类型（`PLAYER_BLACK`, `PLAYER_WHITE`）、基础数据结构（`Point`结构体）	基础设施	避免魔法数字散落各处，一处修改，全局生效；类型安全，编译期检查
`printchessboard.cpp/h`	将内存中的二维数组`board[15][15]`，格式化输出为带坐标、带边框的ASCII棋盘	状态可视化	与核心逻辑完全解耦，未来换成GUI只需重写此模块，不影响搜索算法
`makemove.cpp/h`	执行一次落子：检查坐标合法性、更新棋盘数组、记录最后落子位置	状态转换	是所有模块的“执行者”，必须稳定可靠；独立后便于单元测试（如测试非法坐标是否被拒绝）
`gameover.cpp/h`	判断当前局面是否已分胜负（五连珠），并返回胜方	终止条件判定	搜索算法的“刹车片”，必须高效准确；独立后可轻松替换为更复杂的规则（如禁手）
`createmoves.cpp/h`	遍历棋盘，生成所有当前玩家可下的合法位置列表（`std::vector<Point>`）	动作生成	搜索效率的瓶颈之一；独立后可实验不同启发式（如只考虑中心9x9区域）
`evaluate.cpp/h`	计算当前局面的静态分数（如黑方活三+100，白方冲四-200），分数越高对黑方越有利	状态评估	启发式函数的核心，是AI“棋感”的来源；独立后可自由调整权重、添加新特征
`searchmove.cpp/h`	实现`alphaBetaSearch()`函数，递归搜索指定深度，返回最优着法	动作选择	算法核心，逻辑最复杂；独立后可对比不同剪枝策略、不同深度的效果

main.cpp则像一个冷静的指挥官，它不参与任何具体战斗，只负责按顺序调用这些模块：初始化棋盘 → 循环（显示棋盘 → 获取输入/调用AI → 执行落子 → 判定胜负 → 切换玩家）。这种“指挥官-士兵”模式，让整个流程一目了然。我曾让学生尝试删除searchmove.cpp，只保留evaluate.cpp，然后手动输入着法，结果他们立刻明白了：没有搜索，再好的评估函数也只是一个“裁判”，无法成为“棋手”。

2.2 为什么坚持“每个功能一个cpp”？——对抗认知负荷的工程哲学

你可能会问：把所有函数塞进一个gobang.cpp里，不是更简单吗？答案是：对初学者而言，“简单”恰恰是最危险的陷阱。当所有代码混杂在一起，evaluate()函数里调用isFiveInRow()，isFiveInRow()又调用checkDirection()，而checkDirection()的参数又来自searchmove()的某个局部变量……这种网状依赖，会让大脑瞬间过载。模块化强制你思考接口：evaluate()只需要知道“当前棋盘是什么样子”，它不需要关心棋盘是怎么画出来的，也不需要知道AI下一步想走哪。这种“契约式编程”，是大型软件开发的基石，也是教学中培养工程思维的关键一步。

实操心得：我在指导学生做课程设计时，会让他们先只实现printchessboard.cpp和makemove.cpp，确保能正确显示棋盘并接受用户输入落子。这一步完成后，他们才真正建立起“棋盘是一个可操作对象”的直观感受。接着再加入gameover.cpp，他们就能体验到“胜利”的即时反馈，学习动力大增。最后才引入searchmove.cpp和evaluate.cpp这两个最难的模块。这种渐进式构建，正是模块化设计赋予教学的巨大优势——它把一座山，分解成了一级级可攀爬的台阶。

3. 核心算法原理与实现细节：Alpha-Beta剪枝不是魔法，是精妙的“提前终止”

如果说模块化是骨架，那么searchmove.cpp里的Alpha-Beta剪枝，就是这套程序的心脏。很多教程把它讲得神乎其神，仿佛是某种玄学优化。但在这套代码里，它被还原成了最朴实的C++逻辑：一个带两个额外参数（alpha和beta）的递归函数，以及几行关键的if判断。我们来一层层拨开它的面纱。

3.1 极小化极大（Minimax）：博弈搜索的起点与困境

一切都要从Minimax说起。它的思想极其朴素：假设对手总是做出对你最不利的选择（即“极小化”你的收益），而你则选择在所有可能中，使这个“最不利情况下的收益”最大化（即“极大化”）。对于一个深度为2的搜索树，过程如下：
- 当前轮到你（Max节点），你有3个候选着法A、B、C。
- 对每个着法，你模拟对手（Min节点）的回应。假设对手在A之后有2种回应，分别给出分数10和5；在B之后有3种回应，分数为8、3、7；在C之后有2种回应，分数为12和6。
- Min节点会选择对自己最有利（即对你最不利）的分数：A对应5，B对应3，C对应6。
- 于是，作为Max节点的你，会选择C，因为6是5、3、6中最大的。

问题来了：五子棋的分支因子（平均每个局面有多少合法着法）在开局约为225（15x15棋盘），即使只搜索3层，节点数也高达225³ ≈ 1100万！这在普通PC上根本无法承受。这就是Minimax的“指数爆炸”困境。

3.2 Alpha-Beta剪枝：如何在不牺牲正确性的前提下，砍掉90%的无效计算？

Alpha-Beta剪枝的精髓，在于利用已知信息，提前判断某些子树的计算是徒劳的。它引入了两个边界值：
- alpha：Max节点在当前路径上，已经保证能获得的最高分数下界（即“至少能拿到这么多”）。
- beta：Min节点在当前路径上，已经保证能强加给Max的最低分数上界（即“最多只能让你拿到这么多”）。

剪枝发生的时刻，就是当alpha >= beta。这意味着：Max节点已经发现了一个着法，能保证拿到alpha分；而Min节点则发现，无论自己怎么应对，都至少会让Max拿到beta分，且beta <= alpha。此时，Max节点完全可以放弃探索这条路径，因为继续下去，结果只会比alpha更差（对Max而言），或者不会比beta更好（对Min而言）。这就像一场谈判：甲方说“我至少要100万”，乙方说“我最多给90万”，谈判立刻破裂，无需再讨论细节。

在searchmove.cpp的alphaBetaSearch()函数中，这个逻辑被精准地编码：

// 伪代码，对应实际源码中的核心逻辑
int alphaBetaSearch(Board& board, int depth, int alpha, int beta, bool isMaximizing) {
    if (depth == 0 || gameIsOver(board)) {
        return evaluate(board); // 叶子节点，返回评估分
    }

    if (isMaximizing) {
        int maxEval = -INF;
        for (auto& move : createmoves(board)) {
            makemove(board, move, PLAYER_BLACK);
            int eval = alphaBetaSearch(board, depth-1, alpha, beta, false);
            undoMove(board, move); // 关键！必须撤销，否则污染棋盘状态
            maxEval = std::max(maxEval, eval);
            alpha = std::max(alpha, eval); // 更新alpha
            if (alpha >= beta) { // 剪枝点！
                break; // 跳出循环，不再搜索剩余着法
            }
        }
        return maxEval;
    } else {
        // Min节点逻辑，对称，更新beta并判断beta <= alpha
    }
}

提示：undoMove()函数的存在至关重要。很多初学者会忽略这一点，直接在原棋盘上递归搜索，导致状态混乱。这套代码里，makemove()和undoMove()是成对出现的，这是保证搜索正确性的铁律。

3.3 局面评估函数（`evaluate.cpp`）：AI的“棋感”从何而来？

如果把搜索算法比作AI的“大脑”，那么评估函数就是它的“眼睛”和“直觉”。一个糟糕的评估函数，会让再强大的搜索也南辕北辙。这套程序的评估函数，采用了经典的特征加权求和方法，其核心思想是：识别出棋盘上所有有价值的局部模式（特征），并为每个模式赋予一个经验性权重，最后将所有得分相加。

evaluate.cpp中定义了以下关键特征及其权重（数值为示意，实际源码中已调优）：
- 活四（FourOpen）：四个同色棋子连成一线，两端均为空。权重：+10000。这是必杀技，几乎等同于胜利。
- 冲四（FourClosed）：四个同色棋子连成一线，一端被堵。权重：+1000。威胁巨大，需立即防守。
- 活三（ThreeOpen）：三个同色棋子连成一线，两端均为空。权重：+100。是形成活四的基础。
- 冲三（ThreeClosed）：三个同色棋子连成一线，一端被堵。权重：+10。
- 活二（TwoOpen）：两个同色棋子连成一线，两端均为空。权重：+1。
- 对方活四/冲四：对上述所有对方特征，取负值。权重：-10000, -1000等。

评估函数的实现，本质上是对棋盘上每一个点，向八个方向（横、竖、斜）扫描，寻找上述模式。例如，检测“活四”的伪代码：

bool isFourOpen(const Board& board, int x, int y, int dx, int dy, Player player) {
    // 检查(x,y), (x+dx,y+dy), (x+2dx,y+2dy), (x+3dx,y+3dy)是否都是player
    // 并且(x-dx,y-dy)和(x+4dx,y+4dy)都为空
}

注意：实际源码中，evaluate()函数并非对全盘每个点都做八向扫描（那样太慢），而是只扫描“最近落子点”周围的一定范围（如3格内），因为新产生的威胁几乎都源于此。这是典型的“局部性”优化，既保证了准确性，又提升了速度。

4. 实操过程与核心环节实现：从零开始编译、运行与调试

这套程序的魅力，不仅在于它“能跑”，更在于它“好改、好测、好懂”。下面我将带你走一遍完整的实操流程，从双击test.exe的“开箱即用”，到亲手修改源码、重新编译、观察效果变化的全过程。所有步骤均基于Windows平台，使用最通用的工具链。

4.1 开箱即用：`test.exe`的运行逻辑与两种模式详解

下载资源包后，你首先会看到test.exe。双击运行，你会看到一个清晰的命令行界面：

=== 五子棋AI对战系统 ===
请选择模式：
1. 人机对弈（你执黑，AI执白）
2. AI自对弈（黑方AI vs 白方AI）
请输入选择 (1 或 2):

选择1进入人机对弈。系统会显示一个15x15的棋盘，坐标从(0,0)到(14,14)，左上角为原点。你需要输入两个数字，用空格或逗号分隔，例如7 7表示在棋盘中心落子。AI会在你落子后，短暂思考（通常<1秒），然后在终端上打印出它的落子坐标和思考深度。

选择2进入AI自对弈。此时，main.cpp中的主循环会交替调用两次searchmove()：一次为黑方，一次为白方。程序会自动记录每一步，并在最终输出对局记录，包括总步数、获胜方、以及双方在每一步所用的思考时间。这份记录，正是配套Word报告中“测试结果”章节的数据来源。

实操心得：我建议你先玩几局人机对弈，感受AI的“风格”。你会发现，它在开局会比较“保守”，倾向于占据中心；中盘会变得“激进”，频繁制造活三、冲四；而在残局，它对“活四”的嗅觉极其敏锐。这种行为，完全是由evaluate.cpp中的权重决定的。当你理解了这一点，你就掌握了修改AI“性格”的钥匙。

4.2 从源码到可执行文件：CMake构建流程详解

虽然提供了test.exe，但真正的学习始于编译。资源包根目录下的CMakeLists.txt文件，是整个项目的“构建蓝图”。它告诉编译器：
- 项目名称是GobangAI
- 使用C++11标准（set(CMAKE_CXX_STANDARD 11)）
- 将所有.cpp文件（main.cpp, evaluate.cpp, …）编译成一个可执行文件
- 链接标准库（target_link_libraries(GobangAI ${CMAKE_DL_LIBS})）

编译步骤（以Windows + Visual Studio为例）：
1. 安装CMake和Visual Studio Community（免费）。
2. 打开“x64本机工具命令提示符”（Start Menu中搜索即可）。
3. 进入资源包根目录，执行：
bash mkdir build && cd build cmake -G "Visual Studio 17 2022" -A x64 .. cmake --build . --config Release
4. 编译成功后，build\Release\目录下会出现新的GobangAI.exe。

提示：CMakeLists.txt中有一行add_compile_options(-Wall -Wextra)，它开启了GCC/Clang的全部警告。这意味着，如果你不小心写了int i = 0; for(; i < 15; ) { i++; }这样的死循环，编译器会立刻报错。这是一种“防御性编程”的习惯，值得你在自己的项目中效仿。

4.3 修改与验证：亲手调整AI的“棋力”

现在，让我们来做一件最有成就感的事：亲手提升AI的水平。打开evaluate.cpp，找到evaluate()函数。假设你想让AI更重视“活三”，因为它常常是致胜的关键。在源码中，你可能会找到类似这样的代码段：

// 在evaluate()函数内部，计算活三得分的部分
score += countOpenThrees(board, PLAYER_BLACK) * 100; // 当前权重是100
score -= countOpenThrees(board, PLAYER_WHITE) * 100;

将100改为150，保存文件。然后，回到build目录，重新执行cmake --build . --config Release。几秒钟后，新的GobangAI.exe就诞生了。

如何验证效果？最直接的方法是进行AI自对弈测试。运行新编译的程序，选择模式2，让它自对弈10局。同时，用旧版本的test.exe也进行10局自对弈。对比两份对局记录：
- 新版本的对局，是否出现了更多“黑方通过连续活三获胜”的局面？
- 新版本的平均对局步数，是否比旧版本更短？（因为活三威胁更大，迫使对手更快投降）

这就是工程化的魅力：你的每一次代码修改，都会在终端上产生可量化、可对比的结果。它不再是纸上谈兵，而是真实的因果链条。

5. 常见问题与排查技巧实录：那些文档里不会写的“踩坑”经验

在多年指导学生使用这套程序的过程中，我整理了一份高频问题清单。这些问题，往往不会出现在官方文档里，却是新手最容易卡住的地方。它们不是Bug，而是对C++语言特性、算法本质、工程实践理解不到位的自然体现。

5.1 “AI总是下在同一个地方！”——搜索深度与随机性的迷思

现象：学生抱怨：“我的AI每次开局都下在(7,7)，太呆板了！”
真相：这不是Bug，而是Minimax算法的必然结果。在完全信息、确定性博弈中，如果评估函数和搜索算法完全相同，那么对于同一个初始局面，最优解永远是唯一的。(7,7)（棋盘中心）在五子棋中确实是理论上的最优开局点，因为它能最大化后续发展的可能性。

解决方案：在searchmove.cpp中，为AI添加一个微小的“扰动”。在alphaBetaSearch()返回最终着法列表后，不要直接返回第一个，而是：

// 在searchmove.cpp中，找到返回最佳着法的地方
std::vector<Point> bestMoves = getBestMoves(); // 假设这是获取所有最优着法的函数
if (bestMoves.size() > 1) {
    // 如果有多个着法得分相同，则随机选择一个
    std::random_device rd;
    std::mt19937 g(rd());
    std::shuffle(bestMoves.begin(), bestMoves.end(), g);
}
return bestMoves[0];

这样，AI就拥有了“个性”，不再是冰冷的机器。

5.2 “编译报错：’xxx’ was not declared in this scope”——头文件包含的“蝴蝶效应”

现象：修改了evaluate.h，添加了一个新函数声明，但编译时在searchmove.cpp里报错，说找不到这个函数。
真相：C++的编译是“单文件”的。searchmove.cpp要想使用evaluate.h里的东西，必须在它的开头显式地#include "evaluate.h"。很多学生以为“既然都在一个项目里，就应该自动可见”，这是对C++编译模型的根本误解。

排查技巧：遇到此类错误，第一步不是看报错行，而是看报错文件（searchmove.cpp）的开头几十行。检查是否遗漏了必要的#include。一个好习惯是，在每个.cpp文件的最顶部，按字母顺序列出它所依赖的所有头文件，例如：

#include "createmoves.h"
#include "evaluate.h"
#include "gameover.h"
#include "makemove.h"
#include "searchmove.h"
#include "define.h"

5.3 “自对弈时，AI突然‘自杀’了！”——局面评估的致命盲区

现象：在AI自对弈中，一方AI会莫名其妙地在自己已经形成的“活四”旁边再下一手，导致五连珠被破坏，从而输掉比赛。
真相：这暴露了evaluate.cpp中一个经典的设计缺陷——只评估了“进攻性”特征，却忽略了“防守性”特征的完整性。一个完善的评估函数，不仅要计算“我能做什么”，更要计算“对手下一秒能做什么”。如果evaluate()函数只计算了当前玩家的活四，却没有计算对手在上一手之后，是否已经形成了一个“即将完成的活四”，那么AI就会误判局面。

修复方案：在evaluate()函数中，增加对“对手潜在威胁”的评估。例如，可以添加一个countPotentialFours()函数，专门扫描对手的“冲四”和“活三”，并给予更高的惩罚权重（比如-5000）。这会让AI在进攻的同时，永远保持对对手致命威胁的警惕。

常见问题速查表

问题现象	最可能原因	快速定位方法	修复建议
`test.exe`运行一闪而退	程序在启动时发生未捕获异常（如数组越界）	在命令行中直接运行`test.exe`，观察是否有错误信息闪现	在`main.cpp`最开头添加`try{...} catch(...){ std::cin.get(); }`，让错误窗口停留
修改`evaluate.cpp`后，AI行为无变化	没有重新编译，或者编译的是旧的`build`目录	检查`build\Release\`目录下`GobangAI.exe`的修改时间戳	删除整个`build`目录，重新`mkdir build && cd build && cmake ... && cmake --build ...`
`createmoves.cpp`生成的着法数量远少于预期（如开局只有5个）	`createmoves()`函数中，循环边界写错了（如`i < 14`而非`i < 15`）	在`createmoves.cpp`中，在`return moves;`前添加`std::cout << "Generated " << moves.size() << " moves.\n";`	仔细检查所有`for`循环的起始和结束条件，用`BOARD_SIZE`宏代替硬编码数字
AI思考时间过长（>5秒）	`searchmove.cpp`中，搜索深度设置过高（如`MAX_DEPTH=6`），或`evaluate()`函数过于复杂	在`alphaBetaSearch()`函数入口处添加计时代码	将`MAX_DEPTH`从6降为4，并优化`evaluate()`，只扫描落子点周围3格

6. 教学价值与延伸思考：从五子棋到更广阔的AI世界

这套五子棋AI程序，其终极价值，远不止于教会你如何写一个下棋程序。它是一扇门，一扇通往更广阔人工智能世界的门。当你亲手完成了上面所有的步骤——理解了模块化设计、跟踪了Alpha-Beta的每一层递归、修改了评估函数的权重、解决了编译时的符号错误——你实际上已经掌握了现代AI工程的几个核心范式。

首先，它完美诠释了“分而治之”（Divide and Conquer） 的力量。无论是将一个复杂的博弈问题，分解为“表示、生成、评估、决策”四个原子操作；还是将一个庞大的C++项目，分解为七个职责单一的源文件；抑或是将一个看似无解的指数级搜索问题，通过Alpha-Beta剪枝，压缩到线性可接受的范围——这背后，是一种普适的、强大的思维模型。这种模型，可以迁移到任何领域：设计一个电商推荐系统，你可以将其分解为“用户画像构建”、“商品特征提取”、“相似度计算”、“排序策略”；开发一个自动驾驶模块，你可以将其分解为“感知”、“预测”、“规划”、“控制”。五子棋，就是你手中最趁手的“思维沙盘”。

其次，它揭示了“算法”与“工程”之间那条微妙的分界线。教科书上的Alpha-Beta算法，是一个完美的数学公式；而searchmove.cpp里的实现，则充满了现实的妥协：undoMove()的必要性、MAX_DEPTH的权衡、evaluate()中权重的反复调优、createmoves()中启发式剪枝的引入……这些，都不是算法本身的要求，而是为了让算法能在真实的硬件上、在有限的时间内、以可维护的方式，真正地“工作起来”。这正是工业界与学术界最大的鸿沟之一。而你，已经站在了跨越这条鸿沟的起点。

最后，它提供了一个绝佳的“可扩展性”范本。今天，它是一个15x15的五子棋。明天，你可以：
- 将BOARD_SIZE改为19，把它变成一个简易的围棋AI（尽管围棋的复杂度会指数级上升）；
- 在gameover.cpp中，加入对“禁手”（如“三三”、“四四”）的判定，让它符合正式比赛规则；
- 将printchessboard.cpp替换为一个基于SFML或Qt的图形界面，让它从命令行走向桌面应用；
- 甚至，将searchmove.cpp中的搜索算法，替换为更前沿的蒙特卡洛树搜索（MCTS），去挑战更复杂的棋类。

这一切的起点，都始于你对main.cpp里那十几行主循环逻辑的理解。它不宏大，不炫酷，但它足够坚实，足够透明，足够让你看清，智能，究竟是如何从一行行代码中，生长出来的。

我个人在实际教学中发现，那些最终能写出优秀课程设计的学生，往往不是最早完成的人，而是最晚停止提问的人。他们会反复追问：“为什么alpha要更新为max(alpha, eval)？”“为什么evaluate()里活三的权重是100而不是101？”“如果我把MAX_DEPTH设为1，AI是不是就只会看一步？”——正是这些“打破砂锅问到底”的时刻，标志着他们真正开始理解，而不只是复制。而这套五子棋AI程序，恰好为这种深度探究，提供了最肥沃的土壤。

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