1. 项目概述：从棋盘到代码的旅程

十几年前，当我第一次尝试用Visual C++ 6.0在MFC框架下画出一个九宫格棋盘时，我大概没想到这个简单的爱好会伴随我这么久。中国象棋，这个蕴含了千年智慧的古老游戏，其规则的精妙与逻辑的严谨，对于任何一位程序员来说，都是一个绝佳的练手项目。它不像大型3A游戏那样需要复杂的图形引擎和物理模拟，但它对数据结构、算法逻辑和用户交互的要求却一点也不低。一个完整的象棋程序，本质上是一个状态机，它需要精确地管理棋盘上32个棋子的位置，判断每一步走法的合法性，并最终决定胜负。今天，我想和你深入聊聊，如何用Visual C++这个经典的开发环境，从零开始构建一个功能完备的中国象棋游戏，并在这个过程中，分享那些只有真正动手做过才会知道的“坑”与“窍门”。

这个项目适合谁呢？如果你是一名C++的初学者，希望通过一个具体的、有成就感的项目来巩固面向对象编程、数据结构（尤其是二维数组和链表）的知识，那么象棋游戏再合适不过了。如果你对游戏AI（人工智能）感兴趣，想了解最基本的搜索算法（如极大极小值算法）是如何在棋盘游戏中应用的，这里也是一个绝佳的起点。当然，如果你和我一样，对中国象棋本身有浓厚的兴趣，想亲手打造一个属于自己的“电子棋友”，那这个过程本身就充满了乐趣。我们将从最基础的棋盘绘制、棋子移动逻辑开始，逐步深入到走法生成、规则校验，最后再探讨如何为它注入一个简单的“大脑”——电脑AI。整个项目将完全基于Windows平台和Visual Studio开发环境，确保每一步都有清晰的操作路径和代码示例。

2. 开发环境搭建与项目初始化

2.1 Visual Studio版本选择与MFC框架考量

首先，我们得把“战场”准备好。Visual C++作为微软的经典开发工具集，历经多个版本。对于这个项目，我强烈推荐使用Visual Studio 2019或2022的社区版。它们完全免费，功能强大，并且对C++标准的支持更好。你可能会在网上看到很多古老的教程基于VC++ 6.0或VS 2008，但那些环境过于陈旧，在Win10/Win11上可能会遇到各种兼容性问题，尤其是MFC（Microsoft Foundation Classes）库的部署。

为什么选择MFC？对于象棋游戏这种桌面应用，我们需要一个图形用户界面（GUI）。虽然现在Qt、wxWidgets等跨平台框架很流行，但MFC作为Windows的“原生”框架，与Visual C++的集成度最高，编写传统的Win32窗口程序最为直接。它自带的文档/视图架构和丰富的控件，能让我们快速搭建出包含菜单、工具栏、状态栏和绘图区的标准窗口程序。当然，它的缺点也很明显：代码略显繁琐，设计理念比较老旧。但对于学习和理解Windows消息机制、GDI绘图来说，MFC仍然是一个很好的教材。

注意：安装Visual Studio时，务必在“工作负载”中选择“使用C++的桌面开发”，并在右侧的“安装详细信息”中勾选“用于x86和x64的Visual C++ MFC”。这样才会安装MFC库和头文件。

2.2 创建MFC应用程序项目与核心类设计

打开Visual Studio，新建项目，选择“MFC应用程序”。给项目起个名字，比如“ChineseChess”。在“应用程序类型”中，选择“单个文档”，项目风格可以用“Visual Studio”风格，这样界面看起来比较现代。在“高级功能”中，确保“公共控件清单”是选中的，其他可以默认。

项目创建好后，你会看到自动生成了几个核心类：CChineseChessApp（应用类）、CMainFrame（主框架类）、CChineseChessDoc（文档类）和CChineseChessView（视图类）。对于象棋游戏，我们的数据（棋盘状态、棋子位置、行棋历史）应该放在文档类（CChineseChessDoc）中，因为文档类负责数据的持久化和管理。而所有关于绘制棋盘、响应鼠标点击（走棋）的操作，都应该放在视图类（CChineseChessView）中，因为视图负责显示和交互。

我们需要在文档类中定义核心的数据结构。一个最直接的方式是使用一个9x10的二维数组来表示棋盘：

// 在 CChineseChessDoc.h 中定义 class CChineseChessDoc : public CDocument { // ... 其他代码 public: // 棋子类型枚举 enum PieceType { PIECE_NONE = 0, // 空位 PIECE_R_KING, // 红帅 PIECE_R_GUARD, // 红仕 PIECE_R_BISHOP, // 红相 PIECE_R_KNIGHT, // 红马 PIECE_R_ROOK, // 红车 PIECE_R_CANNON, // 红炮 PIECE_R_PAWN, // 红兵 // 黑方棋子，用负值表示，方便判断阵营 PIECE_B_KING = -1, PIECE_B_GUARD = -2, // ... 其他黑方棋子 }; PieceType m_board[10][9]; // 棋盘数组，10行9列 bool m_bRedTurn; // 当前轮到红方走棋 CPoint m_selectedPos; // 当前选中的棋子位置（-1，-1表示未选中） // ... 还可以添加走棋历史栈、游戏状态等成员 };

在文档类的构造函数或OnNewDocument函数中，我们需要初始化这个棋盘数组，摆好初始的棋子位置。这就是我们游戏的“数据模型”。

3. 棋盘与棋子的图形化呈现

3.1 使用GDI+进行绘图

有了数据模型，下一步就是把它画出来。MFC默认使用GDI（Graphics Device Interface）进行绘图，但GDI功能相对基础。我推荐使用GDI+，它是GDI的增强版，支持抗锯齿、渐变填充、图像Alpha通道等，能让我们的棋盘和棋子看起来更精致。

首先，需要在stdafx.h文件中包含GDI+头文件并链接库：

#include <gdiplus.h> #pragma comment(lib, "gdiplus.lib")

然后，在应用类CChineseChessApp的InitInstance()函数中，初始化GDI+：

// CChineseChessApp::InitInstance() 中 Gdiplus::GdiplusStartupInput gdiplusStartupInput; ULONG_PTR gdiplusToken; Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

并在应用退出时关闭它（可以重写ExitInstance函数）。

3.2 视图类中的绘制逻辑

绘图的核心工作在视图类CChineseChessView的OnDraw函数中。我们需要在这里计算棋盘每个格子的实际像素坐标，然后依次绘制棋盘背景、网格线、九宫格、楚河汉界文字，最后根据m_board数组绘制棋子。

void CChineseChessView::OnDraw(CDC* pDC) { CChineseChessDoc* pDoc = GetDocument(); ASSERT_VALID(pDoc); if (!pDoc) return; Graphics graphics(pDC->GetSafeHdc()); // 创建GDI+ Graphics对象 graphics.SetSmoothingMode(SmoothingModeAntiAlias); // 开启抗锯齿 // 1. 计算绘图参数 CRect clientRect; GetClientRect(&clientRect); int boardSize = min(clientRect.Width(), clientRect.Height()) - 40; // 留边距 int cellSize = boardSize / 9; // 假设9列，计算格子大小 int offsetX = (clientRect.Width() - boardSize) / 2; int offsetY = (clientRect.Height() - boardSize) / 2; // 2. 绘制棋盘背景和网格 SolidBrush backgroundBrush(Color(255, 220, 179, 92)); // 木质黄色背景 graphics.FillRectangle(&backgroundBrush, offsetX, offsetY, boardSize, boardSize); Pen gridPen(Color(255, 0, 0, 0), 2.0f); // 黑色网格线 // 绘制竖线 for (int col = 0; col <= 9; ++col) { int x = offsetX + col * cellSize; graphics.DrawLine(&gridPen, x, offsetY, x, offsetY + boardSize); } // 绘制横线（注意中间楚河汉界不画线，用文字代替） // ... 具体绘制代码略 // 3. 绘制棋子 for (int row = 0; row < 10; ++row) { for (int col = 0; col < 9; ++col) { PieceType piece = pDoc->m_board[row][col]; if (piece != PIECE_NONE) { DrawPiece(graphics, piece, col, row, cellSize, offsetX, offsetY); } } } // 4. 如果棋子被选中，高亮显示选中框 if (pDoc->m_selectedPos.x != -1) { // 绘制一个红色的矩形框 } }

DrawPiece是一个自定义函数，负责根据棋子类型（红或黑）和种类（车、马、炮等），在对应的格子中心绘制一个圆形，并在圆内写上对应的汉字。可以使用Graphics::DrawString来绘制文字，用Graphics::DrawEllipse和Graphics::FillEllipse来绘制圆形边框和填充。

实操心得：棋子的视觉效果是游戏体验的关键。为了美观，我通常会为红黑棋子准备两套颜色方案。红方棋子用红色圆形填充，配白色或黄色文字；黑方棋子用黑色或深灰色填充，配白色文字。圆形的边缘可以加一个稍浅或稍深的描边，以增加立体感。字体建议选择笔画清晰的楷体或宋体，字号要适配格子大小。

4. 游戏逻辑与规则引擎的实现

4.1 鼠标交互与走棋流程

棋盘画好了，接下来要让棋子能“动”起来。这需要在视图类中处理鼠标消息：WM_LBUTTONDOWN（鼠标左键按下）。

void CChineseChessView::OnLButtonDown(UINT nFlags, CPoint point) { CChineseChessDoc* pDoc = GetDocument(); // 1. 将鼠标点击的屏幕坐标转换为棋盘坐标（行，列） CPoint boardPos = PointToBoardPosition(point); if (!IsPositionValid(boardPos)) return; // 点击在棋盘外 // 2. 获取文档中当前选中的位置 CPoint& selectedPos = pDoc->m_selectedPos; if (selectedPos.x == -1) { // 之前没有选中任何棋子 // 尝试选中当前点击位置的棋子 if (pDoc->m_board[boardPos.y][boardPos.x] != PIECE_NONE) { // 检查是否轮到该棋子颜色走（简单判断：红子>0，黑子<0） bool isRedPiece = pDoc->m_board[boardPos.y][boardPos.x] > 0; if (isRedPiece == pDoc->m_bRedTurn) { selectedPos = boardPos; // 选中 Invalidate(); // 触发重绘，显示选中框 } } } else { // 之前已经选中了一个棋子 // 尝试移动选中的棋子到当前点击位置 if (IsMoveValid(pDoc, selectedPos, boardPos)) { // 执行移动：目标位置有子则吃子，无子则移动 pDoc->m_board[boardPos.y][boardPos.x] = pDoc->m_board[selectedPos.y][selectedPos.x]; pDoc->m_board[selectedPos.y][selectedPos.x] = PIECE_NONE; // 切换走棋方 pDoc->m_bRedTurn = !pDoc->m_bRedTurn; // 清空选中状态 selectedPos.x = selectedPos.y = -1; // 检查是否将死？游戏是否结束？（后续实现） // ... Invalidate(); // 重绘整个棋盘 } else { // 走法非法，可能重新选择棋子 // 如果点击的是另一个己方棋子，则改为选中它 if (pDoc->m_board[boardPos.y][boardPos.x] != PIECE_NONE) { bool isRedPiece = pDoc->m_board[boardPos.y][boardPos.x] > 0; if (isRedPiece == pDoc->m_bRedTurn) { selectedPos = boardPos; } } else { // 点击空白处，取消选中 selectedPos.x = selectedPos.y = -1; } Invalidate(); } } CView::OnLButtonDown(nFlags, point); }

这个函数是整个游戏交互的核心。它清晰地体现了“选中-移动”的两步走棋流程。

4.2 核心规则校验函数 IsMoveValid

这是整个项目最复杂、最核心的部分。IsMoveValid函数需要根据中国象棋的规则，判断从from位置到to位置的移动是否合法。它需要综合考虑：

1. 棋子类型：车、马、象、士、将、炮、兵的走法规则完全不同。
2. 路径阻挡：马走日、象走田等是否有“蹩马腿”、“塞象眼”。
3. 特殊规则：炮吃子需要中间有一个“炮架”；将帅不能照面；兵过河后才能横走等。
4. 边界与九宫限制：士、将不能出九宫；兵不能后退等。

我们需要为每种棋子编写一个独立的移动校验函数。这里以最复杂的“马”和“炮”为例：

bool CChineseChessView::IsMoveValid(CChineseChessDoc* pDoc, const CPoint& from, const CPoint& to) { PieceType piece = pDoc->m_board[from.y][from.x]; PieceType targetPiece = pDoc->m_board[to.y][to.x]; // 规则1: 不能吃自己的棋子 if (targetPiece != PIECE_NONE && piece * targetPiece > 0) { return false; // 同为正（红）或同为负（黑），说明是同色 } int dx = to.x - from.x; int dy = to.y - from.y; switch (abs(piece)) { // 取绝对值，只判断棋子类型，不区分红黑 case PIECE_R_KNIGHT: // 马 // 马走日：|dx|+|dy| == 3 且 dx, dy 都不为0 if (abs(dx) + abs(dy) != 3 || abs(dx) == 0 || abs(dy) == 0) { return false; } // 蹩马腿检查 if (abs(dx) == 2) { // 横向走日 if (pDoc->m_board[from.y][from.x + dx/2] != PIECE_NONE) return false; } else { // 纵向走日 (abs(dy)==2) if (pDoc->m_board[from.y + dy/2][from.x] != PIECE_NONE) return false; } break; case PIECE_R_CANNON: // 炮 // 炮必须直线移动 if (dx != 0 && dy != 0) return false; // 非直线 // 计算路径上的棋子数 int stepX = (dx == 0) ? 0 : (dx > 0 ? 1 : -1); int stepY = (dy == 0) ? 0 : (dy > 0 ? 1 : -1); int x = from.x + stepX; int y = from.y + stepY; int blockCount = 0; while (x != to.x || y != to.y) { if (pDoc->m_board[y][x] != PIECE_NONE) { blockCount++; } x += stepX; y += stepY; } // 炮的规则：吃子时，中间必须有且只有一个棋子（炮架）；不吃子时，中间必须无子 if (targetPiece == PIECE_NONE) { if (blockCount != 0) return false; } else { if (blockCount != 1) return false; } break; // ... 其他棋子类型的校验 case PIECE_R_KING: // 将/帅 // 只能走一步，且必须在九宫内 if (abs(dx) + abs(dy) != 1) return false; if (to.x < 3 || to.x > 5) return false; if ((piece > 0 && (to.y < 7 || to.y > 9)) || // 红帅底线 (piece < 0 && (to.y < 0 || to.y > 2))) { // 黑将底线 return false; } // 将帅不能照面（单独函数检查） if (IsKingFacing(pDoc, from, to)) return false; break; } return true; // 所有规则检查通过 }

踩坑记录：实现“马”的规则时，最容易出错的就是“蹩马腿”的逻辑。必须根据马移动的方向（横向“日”还是纵向“日”），精确判断“马腿”的位置。我最初写的时候，直接用(from.x + dx/2, from.y + dy/2)去判断，这在某些斜向移动时是错的。正确的做法是，如果横向移动距离为2（abs(dx)==2），则检查(from.x + dx/2, from.y)位置是否有子；如果纵向移动距离为2（abs(dy)==2），则检查(from.x, from.y + dy/2)位置是否有子。

5. 游戏状态管理与胜负判定

5.1 将帅照面与胜负条件

除了基本的走子规则，中国象棋还有一些全局性的规则需要判断。最经典的就是“将帅照面”。当双方的将/帅处于同一条纵线上，且中间没有任何棋子遮挡时，直接判主动“照面”的一方负（或不允许这样走）。我们需要在每次移动将/帅，以及任何可能移除中间遮挡棋子的移动后，检查这一条件。

bool CChineseChessView::IsKingFacing(CChineseChessDoc* pDoc, const CPoint& from, const CPoint& to) { // 此函数在移动将/帅时被调用，检查移动后是否造成将帅照面 // 1. 先找到红帅和黑将的位置 CPoint redKingPos(-1, -1), blackKingPos(-1, -1); for (int row = 0; row < 10; ++row) { for (int col = 0; col < 9; ++col) { if (pDoc->m_board[row][col] == PIECE_R_KING) redKingPos.SetPoint(col, row); if (pDoc->m_board[row][col] == PIECE_B_KING) blackKingPos.SetPoint(col, row); } } if (redKingPos.x == -1 || blackKingPos.x == -1) return false; // 有一个已经被吃掉了 // 2. 判断是否在同一纵列 if (redKingPos.x != blackKingPos.x) return false; // 3. 判断中间是否有其他棋子 int startRow = min(redKingPos.y, blackKingPos.y) + 1; int endRow = max(redKingPos.y, blackKingPos.y); for (int row = startRow; row < endRow; ++row) { if (pDoc->m_board[row][redKingPos.x] != PIECE_NONE) { return false; // 有遮挡，不照面 } } return true; // 无遮挡，照面！ }

胜负判定则相对简单。在每次走棋后（即OnLButtonDown中成功移动棋子后），我们需要检查：

1. 是否将死对方：判断当前行棋方的对手是否无任何合法走法可走。这需要为对手生成所有可能的走法，并逐一判断是否能够避免被将军。这是一个相对复杂的递归或循环检查。
2. 是否困毙：对手虽然未被将军，但无任何子可动（所有走法都会导致被将军），也算输。
3. 将/帅被吃：直接判负。

在项目初期，我们可以先实现一个简单的胜负判定：当一方的将/帅被吃掉时，游戏结束。更复杂的“将死”判定，可以留到实现AI时一起做，因为AI需要评估局面的胜负。

5.2 走棋历史与悔棋功能

一个友好的象棋游戏必须支持悔棋。这可以通过栈（Stack）数据结构轻松实现。在文档类中，我们定义一个“走棋记录”结构体和一个栈：

struct ChessMove { CPoint from; CPoint to; PieceType capturedPiece; // 被吃掉的棋子，如果没有则为PIECE_NONE // 还可以记录是否为“将军”等额外信息 }; std::stack<ChessMove> m_moveHistory; // 走棋历史栈 std::stack<ChessMove> m_redoStack; // 重做栈（如果需要）

每次成功走棋后，将本次移动的信息（起点、终点、被吃掉的棋子）压入m_moveHistory栈。当用户点击“悔棋”按钮时，从栈顶弹出记录，并反向执行移动：将棋子从to移回from，如果capturedPiece不是PIECE_NONE，则在to位置恢复该棋子。同时，不要忘记切换走棋方标志m_bRedTurn。

注意事项：悔棋时，除了恢复棋盘状态，还需要恢复游戏的其他状态，比如当前选中的棋子（应清空）、是否将军状态等。同时，悔棋后，重做栈（如果有）应该被清空，因为新的走棋分支开始了。

6. 为游戏注入简单的“大脑”：基础AI实现

6.1 极大极小值搜索算法框架

让电脑能够自动走棋，是项目的一个升华。最简单也最经典的算法是极大极小值算法（Minimax）。其核心思想是：假设双方都足够聪明，红方（Max方）总是选择对自己最有利的走法（评估分数最高），黑方（Min方）总是选择对红方最不利（即对自己最有利，评估分数最低）的走法。我们通过递归模拟未来几步的所有可能走法，形成一个搜索树，然后从叶子节点回溯，选择最优的走法。

首先，我们需要一个局面评估函数。这个函数给当前棋盘状态打一个分数，分数越高对红方越有利，越低对黑方越有利。一个非常简单的评估函数可以只计算棋子价值：

int EvaluateBoard(const PieceType board[10][9]) { int redScore = 0, blackScore = 0; // 简单的棋子价值表 const int pieceValue[8] = {0, 10000, 200, 200, 400, 900, 450, 100}; // 对应PIECE_NONE, KING, GUARD... for (int row = 0; row < 10; ++row) { for (int col = 0; col < 9; ++col) { PieceType p = board[row][col]; if (p > 0) redScore += pieceValue[p]; // 红子 else if (p < 0) blackScore += pieceValue[-p]; // 黑子 } } // 还可以加上位置分、灵活度分等 return redScore - blackScore; // 红方视角的分数 }

然后，实现一个递归的Minimax搜索函数：

int Minimax(PieceType board[10][9], int depth, bool isMaxPlayer, int alpha, int beta) { // depth: 搜索深度，为0时返回当前局面评估值 // isMaxPlayer: true表示当前是红方（Max方）走棋 // alpha, beta: Alpha-Beta剪枝参数，用于优化 if (depth == 0) { return EvaluateBoard(board); } // 生成当前局面下，当前行棋方的所有合法走法 std::vector<ChessMove> moves = GenerateAllMoves(board, isMaxPlayer); if (moves.empty()) { // 无棋可走，可能是被将死或困毙，返回一个极端的分数 return isMaxPlayer ? -INFINITY : INFINITY; } if (isMaxPlayer) { // 红方走，找最大值 int maxEval = -INFINITY; for (const ChessMove& move : moves) { // 执行走法 MakeMove(board, move); int eval = Minimax(board, depth - 1, false, alpha, beta); // 撤销走法 UndoMove(board, move); maxEval = max(maxEval, eval); alpha = max(alpha, eval); if (beta <= alpha) { break; // Beta剪枝 } } return maxEval; } else { // 黑方走，找最小值 int minEval = INFINITY; for (const ChessMove& move : moves) { MakeMove(board, move); int eval = Minimax(board, depth - 1, true, alpha, beta); UndoMove(board, move); minEval = min(minEval, eval); beta = min(beta, eval); if (beta <= alpha) { break; // Alpha剪枝 } } return minEval; } }

GenerateAllMoves函数需要遍历己方所有棋子，为每个棋子生成所有合法的目标位置。MakeMove和UndoMove函数用于临时改变棋盘状态，方便递归搜索。

6.2 AI走棋的调用与优化

在游戏轮到电脑方走棋时（比如黑方是电脑），我们调用这个搜索函数：

ChessMove FindBestMoveForAI(PieceType board[10][9], bool isRedAI) { std::vector<ChessMove> moves = GenerateAllMoves(board, isRedAI); ChessMove bestMove; int bestValue = isRedAI ? -INFINITY : INFINITY; int searchDepth = 3; // 搜索深度，越大越强，但耗时指数级增长 for (const ChessMove& move : moves) { MakeMove(board, move); int boardValue = Minimax(board, searchDepth - 1, !isRedAI, -INFINITY, INFINITY); UndoMove(board, move); if ((isRedAI && boardValue > bestValue) || (!isRedAI && boardValue < bestValue)) { bestValue = boardValue; bestMove = move; } } return bestMove; // 返回AI认为最好的走法 }

性能警告：纯粹的Minimax搜索，即使只有3层深度，对于象棋来说可能走法数量也是巨大的，导致搜索缓慢。Alpha-Beta剪枝是必须的优化，它能极大减少需要搜索的节点数。此外，还可以引入走法排序（先搜索吃子、将军等可能好的走法），以便Alpha-Beta剪枝更有效；以及迭代加深（逐渐增加搜索深度）和置换表（记录已搜索过的局面结果）等高级优化技术。对于初学者，实现带Alpha-Beta剪枝的3层搜索，已经能让AI具备基本的防守和吃子能力了。

7. 项目完善与扩展思路

7.1 功能增强与用户体验优化

一个基本的象棋程序完成后，可以从以下几个方面进行完善，让它更像一个成熟的产品：

1. 游戏状态管理：实现“新游戏”、“保存棋局”、“载入棋局”功能。保存棋局可以将当前的m_board数组、m_bRedTurn、m_moveHistory等序列化到文件。MFC的文档类本身就支持序列化（Serialize函数），利用这一点可以很方便地实现。
2. 走棋提示与动画：当鼠标悬停在某个可移动的棋子上时，高亮显示其所有可能的移动位置。走棋时，可以加入棋子平滑移动的动画，提升视觉效果。这可以通过定时器（WM_TIMER）不断重绘棋子位置来实现。
3. 音效：在走棋、吃子、将军、获胜等时刻播放对应的音效。可以使用MFC的PlaySound函数或更强大的音频库。
4. 网络对战：这是更大的挑战。可以使用Windows Socket编程，实现一个简单的客户端-服务器结构，让两个玩家通过网络对战。需要定义一套简单的通信协议来传输棋盘状态和走法。

7.2 高级AI算法探索

如果你对AI部分意犹未尽，可以尝试更高级的算法：

1. 更精细的局面评估：除了棋子价值，加入棋子位置价值表（车占肋道、马卧槽位更优）、棋子灵活度（可走位置数量）、双方威胁程度等因子，让AI的评估更接近人类棋手。
2. 开局库与残局库：为AI预设一些经典的开局走法（开局库），以及在子力很少时使用预先计算好的必胜/必和走法（残局库），可以迅速提升AI在开局和残局阶段的表现。
3. 蒙特卡洛树搜索（MCTS）：这是AlphaGo使用的核心算法之一，在象棋上也有应用。它通过随机模拟对弈来评估走法的好坏，特别适合那些难以用静态规则评估的复杂局面。

7.3 常见问题与调试技巧

在开发过程中，你肯定会遇到各种奇怪的问题。这里分享几个我踩过的坑和解决方法：

1. 棋子移动规则校验总是不对：这是最常遇到的问题。解决方法：单独为每种棋子写一个测试函数，用大量的测试用例（包括边界情况、蹩马腿、塞象眼、炮架等）去验证。在调试时，可以在IsMoveValid函数中设置断点，并打印出from、to坐标以及中间判断的逻辑变量，一步步跟踪。
2. AI思考时间过长，界面卡死：深度搜索是耗时操作。解决方法：务必在AI思考时，将搜索放在一个单独的工作线程中，避免阻塞UI线程。可以使用MFC的AfxBeginThread函数创建线程。同时，在界面上显示一个“思考中...”的提示，并允许用户取消思考。
3. 内存泄漏：如果你使用了new动态分配内存（比如在生成走法列表时），务必记得delete。解决方法：养成使用智能指针（如std::unique_ptr、std::shared_ptr）或者STL容器（如std::vector）的习惯，它们能自动管理内存。对于GDI+对象（如Graphics,Pen,Brush），确保在函数结束时或异常发生时正确释放。
4. 程序在别人电脑上运行报错，提示缺少DLL：这是因为你的程序依赖了特定版本的Visual C++运行时库。解决方法：在发布程序时，将项目属性中“C/C++” -> “代码生成” -> “运行库”设置为“多线程调试(/MTd)”或“多线程(/MT)”，这样运行时库会静态链接到你的exe中，但会增大文件体积。或者，你可以将对应的“Visual C++ Redistributable”安装包（如vc_redist.x64.exe）和你的程序一起打包发给用户。

最后，我想说，用Visual C++实现中国象棋，远不止是完成一个课程作业。它是一个完整的、涉及GUI、数据结构、算法、软件工程的小型项目。当你看到自己编写的程序能够流畅地对弈，当你一步步优化AI让它从“菜鸟”变成“高手”，那种成就感是无与伦比的。这个过程中锻炼的调试能力、架构思维和解决问题的耐心，会让你在未来的编程生涯中受益匪浅。代码的世界就像这棋盘，规则既定，但变化无穷，乐趣也正在于此。