1. 项目概述：为什么一个“联机五子棋”值得用C++ MFC重做一遍？

你可能在微信里随手点开过几十个五子棋小游戏，界面清爽、三秒开局、语音提醒落子——但它们几乎都跑在JavaScript或Unity引擎上。而今天要说的这个“联机五子棋小程序”，它不走流量路线，不靠云服务兜底，从窗口创建、消息循环、绘图坐标到网络收发，每一行代码都钉在Windows原生API层上，用的是C++语言，界面框架是MFC（Microsoft Foundation Classes）。这不是怀旧，是刻意选择：当你要在局域网内实现毫秒级响应的双人对弈、要让老式工控机也能稳定运行、要嵌入某套工业监控系统作为操作员辅助训练模块时，MFC不是备选，而是唯一能兼顾性能、可控性与部署轻量性的方案。

这个项目标题里藏着三个关键锚点：“联机”意味着必须处理TCP连接状态、数据包粘包/拆包、心跳保活与异常断连重试；“五子棋”不是简单画格子，它要求精确的坐标映射、落子逻辑校验（禁手规则可选）、胜负判定算法（八方向扫描+连续计数）、悔棋回滚机制（需维护操作栈）；“C++ MFC”则决定了整个技术栈的底层气质——没有GC，内存自己管；没有跨平台抽象层，Win32 API调用直来直去；界面更新靠InvalidateRect+OnPaint，不是虚拟DOM diff。我去年在某高校实验室帮导师带本科生课程设计时，就坚持让他们用这个组合实现一个可联网、可存档、带AI陪练（极简版Minimax）的五子棋。结果发现：真正卡住学生的从来不是算法，而是MFC消息映射写错导致OnLButtonDown不触发，或是send()返回WSAEWOULDBLOCK却没设成非阻塞模式，导致主线程直接卡死。所以这篇内容，不讲“怎么用MFC拖控件”，只讲“为什么这样写才不会在线上环境崩掉”。

它适合谁？第一类是正在学Windows桌面开发的C++初学者，需要一个有真实交互、有网络、有状态管理的完整闭环项目来建立手感；第二类是嵌入式或工业软件工程师，常需在资源受限的Windows CE或精简版系统中部署轻量GUI，MFC仍是不可替代的选项；第三类是想搞懂“传统桌面程序如何与现代网络模型结合”的进阶者——你会发现，把socket句柄塞进CWinThread派生类、用PostMessage跨线程通知UI更新，这种“土法炼钢”式的架构，反而比某些封装过度的框架更接近本质。接下来我会从设计思路、核心细节、实操步骤到排障记录，一层层剥开这个看似简单的五子棋背后的真实工程逻辑。

2. 整体架构设计：为什么放弃Qt/WinUI，坚持MFC+原始Socket？

2.1 方案选型背后的硬约束

很多人看到“联机五子棋”第一反应是：用Qt写个QMainWindow，加个QTcpSocket，再扔个QGraphicsView画棋盘，十分钟搞定。但实际落地时，你会撞上三堵墙：

• 部署墙：Qt动态库（如Qt5Core.dll、Qt5Network.dll）在目标机器上缺失？用户没装VC++运行时？MFC不同版本（VS2015/2017/2019）的CRT库混用导致崩溃？MFC的DLL（mfc140u.dll等）随VS安装包自带，企业内网分发时只需确认目标机已装对应VC++红istributable，无需额外打包几十MB Qt库。我们曾在一个电力调度终端项目中测试：MFC编译出的EXE（含资源）仅2.1MB，Qt版本打完包超38MB，且首次启动慢1.7秒——这对需要快速响应操作员指令的场景是硬伤。

• 控制墙：Qt的信号槽机制虽优雅，但隐藏了消息循环细节。比如你想在OnPaint里做双缓冲防闪烁，Qt默认用QPainter::render()，但MFC里你可以直接GetDC()->BitBlt()，甚至用GDI+做抗锯齿圆角棋子。更关键的是网络层：QtTcpSocket的readyRead()信号在子线程触发时，若未用moveToThread()正确迁移对象，极易引发跨线程访问崩溃。而MFC中，我们让CWinThread派生类独占一个socket，所有recv()都在该线程内完成，解析完数据后PostMessage到主窗口，UI更新完全在主线程安全执行——这种“线程职责切得像手术刀一样干净”的控制力，是高级框架刻意屏蔽的。

• 调试墙：当网络卡顿导致棋子显示延迟，Qt日志里可能只有一句“QAbstractSocket::readData: socket is not readable”，而MFC配合Wireshark抓包+WSAGetLastError()，能立刻定位是对方send()失败（错误码10053：软件强制关闭连接），还是本机recv()缓冲区溢出（错误码10035：WSAEWOULDBLOCK）。去年帮某自动化设备厂修一个远程调试模块，就是靠在CAsyncSocket::OnReceive()里加了一句TRACE(_T("recv len=%d, err=%d\n"), nBytes, WSAGetLastError())，三分钟锁定是对方设备固件TCP窗口通告为0导致的假死。

所以最终架构定为：单文档界面（SDI）+ 主窗口负责UI渲染与用户输入 + 独立工作线程（CWinThread派生）处理网络通信 + 内存池管理棋局状态 + 自定义序列化协议存档。整个结构没有第三方依赖，编译后一个EXE文件即可运行，连注册表都不写——这才是工业场景要的“绿色软件”。

2.2 模块划分与数据流向

整个程序划分为四个核心模块，彼此通过明确接口通信，避免头文件循环包含：

• UI模块（CMainFrame/CChildView）：继承自CView，重载OnPaint()绘制棋盘（15×15网格）、OnLButtonDown()捕获点击、OnKeyDown()支持空格悔棋。所有界面更新通过InvalidateRect()触发，绝不直接调用UpdateWindow()（防止重入）。

• 游戏逻辑模块（CGameEngine）：纯C++类，不依赖MFC。包含棋盘状态数组（int m_board[15][15]，0=空，1=黑，2=白）、IsWin()胜负判定函数（八方向遍历，时间复杂度O(1)，因棋盘固定大小）、IsValidMove()落子合法性检查（含禁手规则开关）。关键设计：所有状态变更必须通过DoMove(int x, int y, int player)统一入口，内部自动记录操作历史（std::vector<std::tuple<int,int,int>> m_history），支持Undo()回滚。

• 网络模块（CNetWorker）：CWinThread派生类，构造时CreateThread()启动。内部持有一个SOCKET句柄，初始化为非阻塞模式（ioctlsocket(sock, FIONBIO, &ul)）。工作线程循环调用select()检测socket可读性，recv()收到数据后按自定义协议解析（见2.3节），解析成功则PostMessage(WM_NET_DATA, (WPARAM)&packet, 0)通知主窗口。注意：PostMessage参数不能传栈变量地址，必须new分配内存，由主窗口OnNetData()处理完后delete——这是MFC多线程编程铁律。

• 序列化模块（CGameSaver）：负责将m_history和当前棋局保存为二进制文件（.goban），结构体定义如下：

  struct GameHeader { DWORD magic; // 0x474F4241 ('GOBA') WORD version; // 1 WORD boardSize; // 15 DWORD moveCount; // 历史步数 BYTE currentPlayer; // 当前轮到谁 };

  文件头后紧跟moveCount个MoveRecord结构，每个含x,y,player字段。加载时先校验magic和version，避免低版本程序打开高版本存档崩溃。

数据流向严格单向：用户点击 → UI模块 → CGameEngine::DoMove() → 更新状态 → 若为客户端则调用CNetWorker::SendMove() → 网络模块组包发送 → 对方网络模块接收 → 解析 → PostMessage → 主窗口OnNetData() → 调用CGameEngine::DoMove()更新本地棋盘 → InvalidateRect()重绘。这种解耦让单元测试成为可能：你可以用纯控制台程序实例化CGameEngine，喂它一串MoveRecord，验证IsWin()是否在第5步正确返回true。

2.3 自定义网络协议设计：为什么不用JSON/Protobuf？

有人会问：既然要联机，为何不直接用JSON传{"x":7,"y":8,"player":1}？因为嵌入式场景下，解析JSON需要额外链接jsoncpp库（+500KB），且字符串解析比二进制慢3~5倍。而五子棋每步数据极小，我们设计了一个仅12字节的紧凑协议：

总长12字节，发送端memcpy(buffer, &packet, 12)，接收端recv()后先校验Header，再按Type分支处理。粘包处理逻辑写在CNetWorker::ParseBuffer()里：用一个std::vector m_recvBuffer缓存未解析数据，每次recv()追加到末尾，然后while循环查找0x5A5A5A5A，找到后截取后续11字节组成完整包，剩余数据留在buffer等待下次recv()。实测在千兆局域网下，1000步连续落子无丢包，平均延迟12ms（含网络传输+UI重绘）。

这个协议的设计哲学是：用空间换时间，用确定性换灵活性。不支持扩展字段，但保证每一步解析耗时恒定在0.02ms以内（i5-8250U实测），这对需要实时反馈的工业HMI至关重要。

3. 核心细节解析：MFC界面与网络协同的关键陷阱

3.1 MFC消息映射的致命误区：OnLButtonDown为何不触发？

新手最常踩的坑：在CChildView类里写了OnLButtonDown()，编译通过，但鼠标点击棋盘毫无反应。原因往往藏在两个地方：

第一，窗口样式未启用鼠标捕获。MFC默认创建的CView窗口样式是WS_CHILD|WS_VISIBLE，缺少WS_CLIPSIBLINGS（防止子窗口重叠绘制）和WS_CLIPCHILDREN（防止子窗口覆盖父窗口区域），但这不是主因。真正关键的是：必须在PreCreateWindow()中设置CS_DBLCLKS。因为五子棋需要响应单击，而MFC默认不处理单击消息（只处理双击）。正确写法：

BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs) { if (!CView::PreCreateWindow(cs)) return FALSE; cs.style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // 关键：允许接收WM_LBUTTONDOWN cs.dwExStyle |= WS_EX_CLIENTEDGE; return TRUE; }

更稳妥的做法是在CChildView构造函数中显式调用：

CChildView::CChildView() { // 启用鼠标消息 SetCapture(); // 错！不能在这里 // 正确：在OnInitialUpdate()中设置 }

第二，坐标系转换错误。OnLButtonDown(UINT nFlags, CPoint point)传入的point是客户区坐标（Client Coordinates），而棋盘网格是按像素划分的。假设棋盘左上角在(50,50)，每个格子宽高40px，则点击位置换算公式应为：

void CChildView::OnLButtonDown(UINT nFlags, CPoint point) { CRect rect; GetClientRect(&rect); // 获取客户区大小 // 棋盘实际绘制区域：left=50, top=50, right=50+15*40=650, bottom=50+15*40=650 if (point.x < 50 || point.x > 650 || point.y < 50 || point.y > 650) { CView::OnLButtonDown(nFlags, point); return; } // 计算网格坐标：减去边距，除以格子尺寸，四舍五入到最近整数 int gridX = (point.x - 50 + 20) / 40; // +20实现四舍五入 int gridY = (point.y - 50 + 20) / 40; if (gridX >= 0 && gridX < 15 && gridY >= 0 && gridY < 15) { // 调用游戏引擎落子 if (m_gameEngine.DoMove(gridX, gridY, m_currentPlayer)) { // 发送网络包 m_netWorker.SendMove(gridX, gridY, m_currentPlayer); InvalidateRect(NULL); // 触发重绘 } } CView::OnLButtonDown(nFlags, point); }

这里有个易错点：InvalidateRect(NULL)会重绘整个客户区，但如果棋盘只占一部分，应传入具体矩形减少重绘区域，提升性能。实测在4K屏上，全客户区重绘比局部重绘帧率低18%。

提示：调试OnLButtonDown不触发，最快方法是用Spy++工具监听窗口消息。启动Spy++，选中你的程序窗口，勾选"Mouse"消息，点击棋盘看是否收到WM_LBUTTONDOWN。若没收到，说明窗口样式或焦点问题；若收到但OnLButtonDown没进，检查消息映射宏是否漏写ON_WM_LBUTTONDOWN()。

3.2 网络线程与UI线程的安全通信：PostMessage的正确姿势

MFC中跨线程调用UI控件是禁忌，必须通过消息机制。但PostMessage()用错会引发严重问题：

错误示范1：传递栈变量地址

// 危险！pPacket是栈变量，PostMessage返回后即销毁 MovePacket packet = {0x01, 7, 8, 1, GetTickCount()}; PostMessage(WM_NET_DATA, (WPARAM)&packet, 0); // 绝对禁止！

错误示范2：未处理消息队列满

// PostMessage不保证立即投递，若UI线程消息队列满（>10000条），会失败 if (!PostMessage(WM_NET_DATA, (WPARAM)pPacket, 0)) { TRACE(_T("PostMessage failed, error=%d\n"), GetLastError()); delete pPacket; // 必须释放，否则内存泄漏 }

正确做法：在CNetWorker线程中，每次recv()解析出一个包，就new分配内存，PostMessage后由UI线程负责delete：

// 网络线程中 MovePacket* pPacket = new MovePacket; memcpy(pPacket, &rawData, sizeof(MovePacket)); if (!PostMessage(WM_NET_DATA, (WPARAM)pPacket, 0)) { delete pPacket; // 投递失败，自行清理 }

在主窗口CChildView中：

// 在头文件声明消息处理函数 afx_msg LRESULT OnNetData(WPARAM wParam, LPARAM lParam); // 消息映射 ON_MESSAGE(WM_NET_DATA, &CChildView::OnNetData) // 实现 LRESULT CChildView::OnNetData(WPARAM wParam, LPARAM lParam) { MovePacket* pPacket = (MovePacket*)wParam; if (pPacket->type == 0x01) { // 落子 m_gameEngine.DoMove(pPacket->x, pPacket->y, pPacket->player); InvalidateRect(NULL); } delete pPacket; // 关键：此处释放内存 return 0; }

这个模式确保了内存生命周期清晰：网络线程分配，UI线程释放。我们曾在一个项目中因忘记delete，运行24小时后内存增长到1.2GB——因为PostMessage失败时delete被跳过，而成功时又没在OnNetData里delete。

注意：WM_NET_DATA必须自定义，范围在WM_USER+100到0x7FFF之间。不要用WM_USER+1这种常见值，避免与其他控件冲突。

3.3 双缓冲绘图防闪烁：OnPaint中的GDI优化

MFC默认OnPaint()直接在屏幕DC上绘图，窗口大小变化或快速移动时会出现明显闪烁。解决方案是双缓冲：先在内存DC中画好整幅图，再一次性BitBlt到屏幕。

标准写法（在CChildView::OnPaint()中）：

void CChildView::OnPaint() { CPaintDC dc(this); // device context for painting CRect rect; GetClientRect(&rect); // 创建兼容DC和位图 CDC memDC; memDC.CreateCompatibleDC(&dc); CBitmap bitmap; bitmap.CreateCompatibleBitmap(&dc, rect.Width(), rect.Height()); CBitmap* pOldBitmap = memDC.SelectObject(&bitmap); // 设置背景色（避免残留） CBrush brush(RGB(240,240,240)); memDC.FillRect(&rect, &brush); // 绘制棋盘网格 DrawBoardGrid(memDC); // 绘制棋子 DrawStones(memDC); // 一次性拷贝到屏幕 dc.BitBlt(0, 0, rect.Width(), rect.Height(), &memDC, 0, 0, SRCCOPY); // 清理 memDC.SelectObject(pOldBitmap); bitmap.DeleteObject(); memDC.DeleteDC(); }

但这里有个性能陷阱：每次OnPaint都CreateCompatibleBitmap()会频繁申请释放显存，导致GPU负载升高。优化方案是缓存位图，在窗口大小改变时重建：

class CChildView : public CView { private: CBitmap m_bitmap; CDC m_memDC; CSize m_bitmapSize; public: void CreateOffscreenBuffer() { CRect rect; GetClientRect(&rect); if (m_bitmapSize != rect.Size()) { m_bitmapSize = rect.Size(); m_bitmap.DeleteObject(); m_bitmap.CreateCompatibleBitmap(&m_dc, rect.Width(), rect.Height()); m_memDC.SelectObject(&m_bitmap); } } void OnPaint() { CPaintDC dc(this); CreateOffscreenBuffer(); // 复用位图 // ... 绘制逻辑同上，但用m_memDC代替memDC dc.BitBlt(0, 0, m_bitmapSize.cx, m_bitmapSize.cy, &m_memDC, 0, 0, SRCCOPY); } };

实测此优化使OnPaint平均耗时从8.2ms降至1.3ms（i5-8250U），帧率从32FPS提升至60FPS。

4. 实操过程详解：从零开始搭建可运行的联机五子棋

4.1 开发环境配置与项目创建

使用Visual Studio 2019（社区版免费），确保安装“使用C++的桌面开发”工作负载，且勾选“MFC和ATL支持”。新建项目步骤：

1. 文件 → 新建 → 项目，模板选“MFC应用程序”，名称填“GobangOnline”。
2. 应用程序类型：选择“单文档”，取消勾选“使用Unicode库”（为兼容老旧设备，用多字节字符集）。
3. 复合控件：取消所有复选框（不需要ActiveX、Web浏览器等）。
4. 高级功能：仅勾选“打印和打印预览”（后续可扩展）、“在工具栏中显示快捷键提示”（用户体验）。
5. 生成的类：保持默认CMainFrame、CChildView、CGobangOnlineDoc、CGobangOnlineView。

项目创建后，先修改预编译头设置：右键项目 → 属性 → 配置属性 → C/C++ → 预编译头 → 预编译头文件，改为stdafx.h（VS2019默认是pch.h，需手动改回以匹配MFC向导生成的代码）。

关键配置调整：

• 运行时库：属性 → C/C++ → 代码生成 → 运行时库 → 选择“多线程DLL (/MD)”，确保与VC++ Redistributable匹配。
• 字符集：属性 → 常规 → 字符集 → “使用多字节字符集”，避免CString在中文路径下乱码。
• 链接器增量链接：属性 → 链接器 → 常规 → 启用增量链接 → “否”，防止调试时符号丢失。

此时编译运行，应看到标准MFC单文档窗口。下一步添加自定义类。

4.2 游戏引擎类（CGameEngine）的完整实现

在项目中添加新类：右键源文件 → 添加 → 类 → 名称CGameEngine，基类留空。头文件GameEngine.h内容：

#pragma once #include <vector> #include <tuple> class CGameEngine { public: CGameEngine(); ~CGameEngine(); // 落子，返回true表示成功 bool DoMove(int x, int y, int player); // 悔棋 bool Undo(); // 判胜 int IsWin() const; // 0=未胜, 1=黑胜, 2=白胜 // 清空棋盘 void ClearBoard(); // 获取棋盘状态 const int (&GetBoard())[15][15] { return m_board; } // 获取历史步数 size_t GetMoveCount() const { return m_history.size(); } private: int m_board[15][15]; // 棋盘状态 std::vector<std::tuple<int, int, int>> m_history; // 历史：(x,y,player) bool m_enableForbidden; // 是否启用禁手（黑方禁手） };

实现文件GameEngine.cpp：

#include "stdafx.h" #include "GameEngine.h" CGameEngine::CGameEngine() { ClearBoard(); m_enableForbidden = true; } CGameEngine::~CGameEngine() {} void CGameEngine::ClearBoard() { for (int i = 0; i < 15; i++) { for (int j = 0; j < 15; j++) { m_board[i][j] = 0; } } m_history.clear(); } bool CGameEngine::DoMove(int x, int y, int player) { // 边界检查 if (x < 0 || x >= 15 || y < 0 || y >= 15) return false; if (m_board[x][y] != 0) return false; // 已有棋子 m_board[x][y] = player; m_history.emplace_back(x, y, player); return true; } bool CGameEngine::Undo() { if (m_history.empty()) return false; auto& last = m_history.back(); int x = std::get<0>(last); int y = std::get<1>(last); m_board[x][y] = 0; m_history.pop_back(); return true; } int CGameEngine::IsWin() const { // 八方向：横、竖、两斜 const int dirs[4][2] = { {1,0}, {0,1}, {1,1}, {1,-1} }; for (int i = 0; i < 15; i++) { for (int j = 0; j < 15; j++) { if (m_board[i][j] == 0) continue; int player = m_board[i][j]; for (int d = 0; d < 4; d++) { int count = 1; // 正向 for (int k = 1; k < 5; k++) { int ni = i + k * dirs[d][0]; int nj = j + k * dirs[d][1]; if (ni < 0 || ni >= 15 || nj < 0 || nj >= 15) break; if (m_board[ni][nj] == player) count++; else break; } // 反向 for (int k = 1; k < 5; k++) { int ni = i - k * dirs[d][0]; int nj = j - k * dirs[d][1]; if (ni < 0 || ni >= 15 || nj < 0 || nj >= 15) break; if (m_board[ni][nj] == player) count++; else break; } if (count >= 5) return player; } } } return 0; }

将CGameEngine成员变量加入CChildView类：

// ChildView.h class CChildView : public CView { private: CGameEngine m_gameEngine; // ... 其他成员 };

在CChildView::OnInitialUpdate()中初始化：

void CChildView::OnInitialUpdate() { CView::OnInitialUpdate(); // 初始化游戏引擎 m_gameEngine.ClearBoard(); }

4.3 网络模块（CNetWorker）的线程安全实现

添加新类CNetWorker，基类CWinThread。头文件NetWorker.h：

#pragma once #include <winsock2.h> #include <vector> class CNetWorker : public CWinThread { DECLARE_DYNCREATE(CNetWorker) public: CNetWorker(); virtual ~CNetWorker(); // 启动线程 BOOL Start(SOCKET sock); // 发送落子 void SendMove(int x, int y, int player); // 发送心跳 void SendHeartbeat(); protected: SOCKET m_sock; bool m_bRunning; CRITICAL_SECTION m_cs; virtual BOOL InitInstance() override; virtual int ExitInstance() override; virtual int Run() override; private: void ParseBuffer(const std::vector<BYTE>& buffer); void ProcessPacket(const BYTE* data, int len); };

实现文件NetWorker.cpp：

#include "stdafx.h" #include "NetWorker.h" #include "ChildView.h" IMPLEMENT_DYNCREATE(CNetWorker, CWinThread) CNetWorker::CNetWorker() : m_sock(INVALID_SOCKET), m_bRunning(false) { InitializeCriticalSection(&m_cs); } CNetWorker::~CNetWorker() { DeleteCriticalSection(&m_cs); } BOOL CNetWorker::Start(SOCKET sock) { m_sock = sock; m_bRunning = true; return AfxBeginThread(this) != nullptr; } void CNetWorker::SendMove(int x, int y, int player) { if (m_sock == INVALID_SOCKET) return; BYTE buffer[12]; memset(buffer, 0, sizeof(buffer)); *(DWORD*)buffer = 0x5A5A5A5A; // Header buffer[4] = 0x01; // Type: move buffer[5] = (BYTE)x; buffer[6] = (BYTE)y; buffer[7] = (BYTE)player; *(DWORD*)(buffer + 8) = GetTickCount(); int sent = send(m_sock, (const char*)buffer, 12, 0); if (sent != 12) { TRACE(_T("SendMove failed, sent=%d, err=%d\n"), sent, WSAGetLastError()); } } BOOL CNetWorker::InitInstance() { return TRUE; } int CNetWorker::ExitInstance() { return 0; } int CNetWorker::Run() { while (m_bRunning) { fd_set readfds; FD_ZERO(&readfds); FD_SET(m_sock, &readfds); timeval timeout = {0, 10000}; // 10ms超时 int result = select(0, &readfds, nullptr, nullptr, &timeout); if (result > 0 && FD_ISSET(m_sock, &readfds)) { BYTE recvBuf[1024]; int nBytes = recv(m_sock, (char*)recvBuf, sizeof(recvBuf), 0); if (nBytes > 0) { // 解析缓冲区 std::vector<BYTE> buffer(recvBuf, recvBuf + nBytes); ParseBuffer(buffer); } else if (nBytes == 0) { // 对方关闭连接 m_bRunning = false; ::PostMessage(AfxGetMainWnd()->m_hWnd, WM_NET_DISCONNECT, 0, 0); break; } else { int err = WSAGetLastError(); if (err != WSAEWOULDBLOCK) { m_bRunning = false; break; } } } Sleep(1); // 防止CPU空转 } return 0; } void CNetWorker::ParseBuffer(const std::vector<BYTE>& buffer) { static std::vector<BYTE> s_recvBuffer; s_recvBuffer.insert(s_recvBuffer.end(), buffer.begin(), buffer.end()); size_t pos = 0; while (pos + 12 <= s_recvBuffer.size()) { if (*(DWORD*)&s_recvBuffer[pos] == 0x5A5A5A5A) { ProcessPacket(&s_recvBuffer[pos], 12); pos += 12; } else { pos++; } } // 移除已处理数据 if (pos > 0) { s_recvBuffer.erase(s_recvBuffer.begin(), s_recvBuffer.begin() + pos); } } void CNetWorker::ProcessPacket(const BYTE* data, int len) { if (len < 12) return; BYTE type = data[4]; switch (type) { case 0x01: { // 落子 int x = data[5]; int y = data[6]; int player = data[7]; // 发送消息到UI线程 ::PostMessage(AfxGetMainWnd()->m_hWnd, WM_NET_DATA, (WPARAM)new MovePacket{type, x, y, player, *(DWORD*)(data+8)}, 0); break; } case 0x03: // 心跳，不处理 break; } }

在CChildView中添加成员：

// ChildView.h class CChildView : public CView { private: CNetWorker* m_pNetWorker; SOCKET m_clientSock; // ... 其他 };

在CChildView::OnInitialUpdate()中初始化网络：

void CChildView::OnInitialUpdate() { CView::OnInitialUpdate(); m_gameEngine.ClearBoard(); // 初始化socket WSADATA wsaData; if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) { AfxMessageBox(_T("WSAStartup failed")); return; } m_clientSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (m_clientSock == INVALID_SOCKET) { AfxMessageBox(_T("socket creation failed")); return; } // 设置非阻塞 u_long ul = 1; ioctlsocket(m_clientSock, FIONBIO, &ul); // 连接服务器（示例IP） sockaddr_in serverAddr; serverAddr.sin_family = AF_INET; serverAddr.sin_port = htons(8080); serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); connect(m_clientSock, (sockaddr*)&serverAddr, sizeof(serverAddr)); // 启动网络线程 m_pNetWorker = new CNetWorker(); m_pNetWorker->Start(m_clientSock); }

别忘了在CChildView::~CChildView()中清理：

CChildView::~CChildView() { if (m_pNetWorker) { m_pNetWorker->m_bRunning = false; delete m_pNetWorker; m_pNetWorker = nullptr; } if (m_clientSock != INVALID_SOCKET) { closesocket(m_clientSock); WSACleanup(); } }

4.4 客户端与服务器的简易联机测试

为快速验证联机功能，我们写一个极简TCP服务器（控制台程序），监听8080端口，接受两个客户端连接，转发消息：

// Server.cpp (独立控制台项目) #include <winsock2.h> #include <iostream> #pragma comment(lib, "ws2_32.lib") int main() { WSADATA wsaData; WSAStartup(MAKEWORD(2,2), &wsaData); SOCKET listenSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(8080); addr.sin_addr.s_addr = INADDR_ANY; bind(listenSock, (sockaddr*)&addr, sizeof(addr)); listen(listenSock, 5); SOCKET clients[2] = {INVALID_SOCKET, INVALID_SOCKET}; int clientCount = 0; std::cout << "Server started on port 8080\n"; while (clientCount < 2) { SOCKET client = accept(listenSock, nullptr, nullptr); if (client != INVALID_SOCKET) { clients[clientCount++] = client; std::cout << "Client " << clientCount << " connected\n"; } } // 转发消息 while (true) { for (int i = 0; i < 2; i++) { BYTE buf[1024];