基于C++、MFC和Windows套接字实现的简单聊天室程序开发

一、一个简单的聊天室程序

该程序由服务器端和客户端两个项目组成，这两个项目均基于对话框的程序。服务器端项目负责管理客户端的上线、离线状态，以及转发客户端发送的信息。客户端项目则负责向服务器发送信息，并接收来自服务器的信息，并将接收到的信息显示在客户端界面上。

1.1创建服务器端界面

1.创建项目

打开 VS2022 软件，选择创建 MFC 项目，项目名称为ChatServer。选择应用程序类型为基于对话框。在创建项目的过程中，在“高级功能”选项中勾选“Windows 套接字”。具体步骤如下所示：

1. 启动 VS2022 软件。
2. 在“启动窗口”中，选择“创建新项目”。
3. 在“创建新项目”窗口中，搜索并选择“MFC 应用程序”，然后点击“下一步”。
4. 在“配置新项目”窗口中，将项目名称设置为“ChatServer”，并选择项目的保存位置。
5. 点击“创建”按钮。
6. 在“创建 MFC 应用程序”向导中，选择“基于对话框”的应用程序类型。
7. 在“高级功能”选项中，勾选“Windows 套接字”。
8. 完成所有设置后，点击“完成”按钮，VS2022 将生成一个基于对话框的 MFC 项目，并启用 Windows 套接字功能。

最终进入的界面如下所示：

2.编辑对话框资源

打开对话框资源，并进行以下操作以设置对话框的标题和添加所需的控件：

1. 设置对话框标题和边框样式：

   • 在解决方案资源管理器中，展开“资源文件夹”并找到“Dialog”资源。
   • 双击主对话框资源（IDD_CHATSERVER_DIALOG`）以打开对话框编辑器或如上图已经打开对话框编辑器。
   • 右键点击对话框的空白区域，选择“属性”（Properties）。
   • 在属性窗口中，找到“描述文字”属性，将其值设置为“聊天室服务器端”。
   • 找到“边框”属性，将其值设置为“对话框外框”。

2. 删除对话框中原有的控件：

   • 选择对话框中默认生成的所有控件（如静态文本、按钮等），然后按 Delete 键或按鼠标右键显示删除按钮删除这些控件。

3. 添加新的控件：

   • 在工具箱中找到并选择需要的控件，然后将其拖放到对话框上进行布局。
   • 具体控件和布局请根据需求进行设置，例如：
     • 编辑框（Edit Control）：用于显示和输入文本信息。
     • 按钮（Button）：用于执行启动、停止服务器等操作。
     • 列表框（List Box）或列表控件（List Control）：用于显示客户端连接信息或聊天记录。

按照上述设置添加如下所示的控件：

点击控件并右键选择“属性”选项，即可更改控件的设置，例如描述文字等。按照下表中的设置进行调整：

最终效果如下所示：

3.为控件添加关联变量

为了方便获取和设置对话框中控件的值，可以为对话框的部分控件添加关联变量。在解决方案资源管理器中，右击项目名称ChatServer，在弹出的快捷菜单中选择“类向导”，打开“类向导”对话框。在类向导对话框中，确保项目名称是ChatServer，在“类名”下方选择CChartServerDlg，单击“成员变量”标签，流程如下所示：

下面为控件IDC_EDIT_CLIENTS添加关联变量。在上图中，选中IDC_EDIT_CLIENTS，单击“添加变量”按钮，出现“添加控制变量”对话框。在“类别”下方选择“值”，“名称”下方输入m_nClients，“变量类型”下方输入unsigned int，单击“完成”按钮，返回到“类向导”对话框，控件IDC_EDIT_CLIENTS的关联变量m_nClients添加完毕。流程如下所示：

按照上面同样的方法为其他控件添加关联变量，最终控件的关联变量以及类型如下表所示：

添加完之后如下所示：

4.对话框初始化

为了避免每次运行服务器端程序都要输入IP地址、端口等数据，可为这两个控件设置初值。打开文件ChatServerDlg.cpp，找到对话框初始化函数OnInitDialog()，在“//TODO：”一行的后面输入以下代码：

	// TODO: 在此添加额外的初始化代码
	m_ipServer.SetAddress(127, 0, 0, 1);
	m_nPort = 8888;
	m_nClients = 0;
	UpdateData(false);

接下来编译运行程序：

程序运行结果如下所示：

上面添加的初始化代码，为IP地址控件设置初值“127.0.0.1”，为端口编辑框关联变量m_nPort赋值8888，为已连接客户端编辑框关联变量m_nClients赋值0，最后调用函数UpdateData(false)，将控件关联变量的值显示在对应的控件中。如果函数UpdateData()的参数为true，则将控件中显示的值保存在对应的关联变量中。

1.2创建客户端界面

1.创建项目

与ChatServer项目类似，创建MFC项目ChatClient，应用程序类型选择基于对话框，在“高级功能”中勾选“Windows套接字”

2.编辑对话框资源

打开对话框资源，将对话框的标题（文字描述）设置为“聊天室客户端”，边框选择“对话框外框”。删除对话框中原有的控件，添加如下图所示的控件：

除了静态控件，对话框中其他控件的ID以及属性如下表：

3.为控件添加关联变量

与服务器项目类似，为客户端对话框的部分部件添加关联变量，具体添加方法与服务器端对话框相同，添加的关联变量如下表：

4.对话框初始化

与服务器对话框类似，在客户端对话框的初始化函数中为IP地址和端口提供初始化值。打开文件ChatClientDlg.cpp，找到对话框初始化函数OnInitDialog()，在“//TODO：”一行的后面输入以下代码：

	// TODO: 在此添加额外的初始化代码
	m_ipServer.SetAddress(127, 0, 0, 1);
	m_nPort = 8888;
	UpdateData(false);

编译运行程序，程序运行结果如下所示：

1.3服务器端编程

1.对话框类中添加数据成员

因为在对话框类中CChatServerDlg中需要用到vector，则在ChatServerDlg.h文件的开始部分加入以下两行代码：

#include<vector>
using namespace std;

在服务器端要记录每个连接客户端的信息，首先要定义一个保存客户端信息的类ClientItem，之后用vector保存所有连接客户端的信息

在ChatServerDlg.h文件中，找到服务器端对话框类CChatServerDlg的定义处，在其上方添加ClientItem类的定义：

class CChatServerDlg;
class ClientItem {
public:
	SOCKET cltSocket;
	CString cltIP;
	int cltPort;
	CChatServerDlg* pChatDlg;
	ClientItem(int cltPort=8888, SOCKET cltSocket=INVALID_SOCKET, CChatServerDlg*  pChatDlg=nullptr)
		:cltPort(cltPort),cltSocket(cltSocket), pChatDlg(pChatDlg){}
};

从上面的代码可以看到，需要保存的客户端信息有对应的socket、IP地址、端口。为了能在ClientItem类中访问对话框类的成员，可以再ClientItem类中使用属性pChatDlg保存服务器端对话框的地址。

在CChatServerDlg类中加入以下两个属性：

	//监听客户端连接请求的socket以及保存连接用户端的信息
	SOCKET m_listenSocket;
	vector<ClientItem*> m_clients;

第一个属性是监听客户端连接请求的socket；第二个属性是一个向量，用于保存连接客户端的信息

在构造函数中将加入以下代码：

CChatServerDlg::CChatServerDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_CHATSERVER_DIALOG, pParent)
	, m_nClients(0)
	, m_nPort(0)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	m_listenSocket = INVALID_SOCKET;
}

将m_listenSocket 初始化为 INVALID_SOCKET。

2.添加“启动服务器”按钮的消息响应函数

使用类向导添加“启动服务器”按钮的消息响应函数，打开“类向导”对话框，选择项目ChatServer，选择类CChatServerDlg，然后选择“命令”标签，找到并选中IDC_START，在“消息”中选择BN_CLICKED，如下图所示：

在上图中，单击“添加处理程序”按钮，完成“启动服务器”按钮的消息响应函数OnClickedStart()的添加，在函数OnClickedStart()中添加如下代码：

void CChatServerDlg::OnClickedStart()
{
	// TODO: 在此添加控件通知处理程序代码
	UpdateData(true);							//将对话框控件中的值保存到控件关联变量中
	DWORD dwIP;									//32位无符号整数表示的IP
	m_ipServer.GetAddress(dwIP);				//获取控件中的IP地址
	m_listenSocket = socket(AF_INET, SOCK_STREAM, 0);
	if (m_listenSocket == INVALID_SOCKET) {
		AfxMessageBox(_T("创建socket失败"));
		return;
	}
	//绑定端口和IP
	sockaddr_in serverAddr = { 0 };
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(m_nPort);
	serverAddr.sin_addr.s_addr = htonl(dwIP);
	if (bind(m_listenSocket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
		AfxMessageBox(_T("绑定失败"));
		return;
	}
	//开始监听(listen())
	if (INVALID_SOCKET == listen(m_listenSocket, 5)) {
		AfxMessageBox(_T("监听失败"));
		return;
	}
	m_edtMsg.SetWindowTextW(_T("服务器已启动！\r\n"));
	GetDlgItem(IDC_START)->EnableWindow(false);
	//创建监听线程，监听线程函数名为AccpThreadProc
	HANDLE h = CreateThread(nullptr, 0, AccpThreadProc, this, 0, nullptr);
	if (h != nullptr)
		CloseHandle(h);
	return;
}

3.创建监听线程函数

下面给出监听线程函数的定义。将监听线程函数定义为类的静态成员函数，首先在CChatServerDlg类中给出函数AccpThreadProc()的声明，代码如下：

static DWORD WINAPI AccpThreadProc(LPVOID pParam);

然后给出函数的定义，代码如下：

//用于监听的线程函数，监听线程函数作为类的成员函数必须需定义为静态函数
DWORD WINAPI CChatServerDlg::AccpThreadProc(LPVOID pParam) {
	CChatServerDlg* thisDlg = (CChatServerDlg*)pParam;
	while (true) {
		sockaddr_in clientAddr = { 0 };
		int iLen = sizeof(sockaddr_in);
		//accept()函数取出客户端请求连接队列中最前面的请求，并创建与该客户端通信的套接字
		SOCKET accSock = accept(thisDlg->m_listenSocket, (sockaddr*)&clientAddr, &iLen);
		if (accSock == INVALID_SOCKET) {
			AfxMessageBox(_T("监听失败！ "));
			return 0;
		}
		ClientItem* pClient = new ClientItem();		//创建一个CClient对象
		pClient->cltSocket = accSock;
		char IP[20];			//点分十进制表示的IP
		inet_ntop(AF_INET, (void*)&clientAddr.sin_addr, IP, 16);
		pClient->cltIP.Format(_T("%S"), IP);			//IP地址
		pClient->cltPort = clientAddr.sin_port;		//端口
		pClient->pChatDlg = thisDlg;					//服务器对话框
		thisDlg->m_clients.push_back(pClient);			//将pClient添加到向量m_clients中
		++thisDlg->m_nClients;							//登录客户端数加1
		CString msgIP(pClient->cltIP);
		CString msgPort;
		msgPort.Format(_T(":%d"), pClient->cltPort);
		CString msg = msgIP + msgPort + "登录";		//smg格式为“IP:端口 登录”
		//想对话框发送消息，更新界面信息
		::SendMessage(thisDlg->GetSafeHwnd(), WM_UPDATE_MSG, NULL, (LPARAM)&msg);
		//创建接受客户端消息的线程
		HANDLE h = CreateThread(nullptr, 0, RecvThreadProc, pClient, 0, nullptr);
		if (h != nullptr) {
			CloseHandle(h);
		}
	}
	return 0;
}

4.创建接收数据线程函数

下面定义接受客户端消息的线程函数RecvThreadProc()，在CChatServerDlg类中添加函数的声明，代码如下：

static DWORD WINAPI RecvThreadProc(LPVOID pParam);

RecvThreadProc()函数的定义如下：

//接收数据并处理，每个客户端对应一个线程
DWORD WINAPI CChatServerDlg::RecvThreadProc(LPVOID pParam) {
	ClientItem* thisClient = (ClientItem*)pParam;
	while (true) {
		TCHAR buffer[256] = { 0 };
		int nRecv = recv(thisClient->cltSocket, (char*)buffer, sizeof(buffer), 0);
		if (nRecv <= 0) {				//-1：网络出错	0：对方关闭连接	，从向量m_clients中删除thisClient
			removeClient(thisClient->pChatDlg->m_clients, thisClient);
			return 0;
		}
		//在消息buffer的前面加上发送客户端的IP地址和端口，然后转发给每一个客户端
		CString strPort;
		strPort.Format(_T("%d"), thisClient->cltPort);
		CString msg = thisClient->cltIP + "-" + strPort + ":" + buffer;
		TCHAR sendBuf[256] = { 0 };
		_tcscpy_s(sendBuf, 256, msg);
		auto it = thisClient->pChatDlg->m_clients.begin();
		for (; it != thisClient->pChatDlg->m_clients.end(); ++it) {
			ClientItem* pClient = *it;
			int bufLen = _tcslen(sendBuf) * sizeof(TCHAR);
			int len = send(pClient->cltSocket, (char*)sendBuf, bufLen, 0);
			if (len <= 0) {		//发送失败，从向量m_clients中删除pClient
				removeClient(thisClient->pChatDlg->m_clients, pClient);
			}
		}
	}
	return 0;
}

5.添加removeCilent函数

为了使用方便，将removeClient()函数也定义为静态函数，首先在类中声明，代码如下：

static void removeClient(vector<ClientItem*>clients, ClientItem* theClient);

removeClient()函数的定义如下：

//在向量clients中，将theClient删除
void CChatServerDlg::removeClient(vector<ClientItem*>clients, ClientItem* theClient) {
	--(theClient->pChatDlg->m_nClients);			//登录客户端数减1
	//向对话框发送消息，通知客户端离线
	CString msgIP(theClient->cltIP);
	CString msgPort;
	msgPort.Format(_T(":%d"), theClient->cltPort);
	CString msg = msgIP + msgPort + "离开";
	//向对话框发送消息，显示有客户端离线的消息
	::SendMessage(theClient->pChatDlg->GetSafeHwnd(), WM_UPDATE_MSG, NULL, (LPARAM)&msg);
	//将客户端从客户端向量中删除
	vector<ClientItem*>::iterator it;
	for (it = clients.begin(); it != clients.end(); ++it) {
		ClientItem* pClient = *it;
		if (pClient->cltSocket == theClient->cltSocket) {			//找到要删除的客户端
			clients.erase(it);
			break;
		}
	}
	delete theClient;			//删除客户端
}

6.对话框自定义消息响应函数

要发送自定义消息，需要定义消息宏、添加消息响应函数以及完成消息映射

(1)消息宏的定义。在ChatServerDlg.h文件的开始部分加入消息宏定义，代码如下：

#define WM_UPDATE_MSG WM_USER+100

为了防止用户定义的消息ID与系统的消息ID冲突，Microsoft定义了一个宏WM_USER，小于WM_USER的ID被系统使用，大于WM_USER的ID被用户使用。因此，这里定义的宏WM_UPDATE_MSG的值是WM_USER+100。

(2)添加消息响应函数。在CChatServerDlg类中添加消息响应函数的声明，代码如下：

LRESULT OnUpdateMsg(WPARAM w, LPARAM l);

在CCHatServerDlg.cpp文件中给出OnUpdateMsg()函数的定义，代码如下：

LRESULT CChatServerDlg::OnUpdateMsg(WPARAM w, LPARAM l) {
	CString* strMsg = (CString*)l;
	int len = m_edtMsg.GetWindowTextLength();		//原来编辑框中文本的长度
	m_edtMsg.SetSel(len, len);
	m_edtMsg.ReplaceSel(*strMsg + _T("\r\n"));		//在原来文本的后面增加文本strMsg
	UpdateData(false);
	return 0;
}

需要显示在对话框中的消息由函数的第二个参数传入，将消息追加在编辑框原来的内容之后。最后调用函数UpdateData(false)，将已登陆客户端的数量更新

(3)完成消息映射。在ChatServerDlg.cpp文件中，找到BEGIN_MESSAGE_MAP(CChatServerDlg,CDialogEx)和END_MESSAGE_MAP()之间的代码块，在这段代码块中加入消息映射。添加消息映射后的代码如下：

BEGIN_MESSAGE_MAP(CChatServerDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON2, &CChatServerDlg::OnBnClickedButton2)
	ON_BN_CLICKED(IDC_START, &CChatServerDlg::OnClickedStart)
	ON_MESSAGE(WM_UPDATE_MSG, OnUpdateMsg)
	ON_BN_CLICKED(IDC_EXIT, &CChatServerDlg::OnClickedExit)
END_MESSAGE_MAP()

ON_MESSAGE(WM_UPDATE_MSG, OnUpdateMsg)的作用是，当街收到消息WM_UPDATE_MSG时，就会调用函数OnUpdateMsg()

1.4客户端编程

1.对话框类中添加数据成员

在ChatClientDlg类中加入负责与服务器端通信的socket属性，代码如下：

SOCKET m_Socket;

在构造函数中将加入以下代码，对属性m_Socket初始化：

CChatClientDlg::CChatClientDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_CHATCLIENT_DIALOG, pParent)
	, m_nPort(0)
	, m_strSend(_T(""))
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	m_Socket = INVALID_SOCKET;
}

2.添加“登录”按钮的消息响应函数

使用类向导为对话框类CChatClientDlg添加“登录”按钮的消息响应函数，方法与前面为服务器端对话框类添加“启动服务器”按钮的消息响应函数相同，在函数中添加如下代码：

void CChatClientDlg::OnClickedLogin()
{
	// TODO: 在此添加控件通知处理程序代码
	UpdateData(true);						//将对话框控件中的值保存到控件关联变量中
	DWORD dwIP;								//32位无符号正式表示的IP
	m_ipServer.GetAddress(dwIP);			//获取IP地址
	m_Socket = socket(AF_INET, SOCK_STREAM, 0);
	if (m_Socket == INVALID_SOCKET) {
		AfxMessageBox(_T("创建socket失败"));
		return;
	}
	//连接服务器(绑定socket到服务器的IP地址和端口)
	sockaddr_in serverAddr;
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(m_nPort);			//函数htons()将参数转换为网络字节序
	serverAddr.sin_addr.s_addr = htonl(dwIP);		//函数htonl()将参数转换为网络字节序
	if (connect(m_Socket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
		AfxMessageBox(_T("连接失败"));
		return;
	}
	m_edtMsg.SetWindowTextW(_T("登陆成功！\r\n"));
	GetDlgItem(IDC_LOGIN)->EnableWindow(false);		//禁用“登录”按钮
	GetDlgItem(IDC_SEND)->EnableWindow(true);		//启用“发送”按钮
	//创建接收服务器的线程
	HANDLE h = CreateThread(nullptr, 0, RecvThreadProc, this, 0, nullptr);
	if (h != nullptr)
		CloseHandle(h);
}

3.创建接收数据线程函数

下面给出接受信息线程函数的定义。将线程函数定义为类的静态成员函数，首先在CCHatServerDlg类中给出函数AccpThreadProc()的声明，代码如下：

static DWORD WINAPI RecvThreadProc(LPVOID pParam);

然后给出函数的定义，代码如下：

DWORD WINAPI CChatClientDlg::RecvThreadProc(LPVOID pParam) {
	CChatClientDlg* thisDlg = (CChatClientDlg*)pParam;
	while (true) {
		TCHAR buffer[256] = { 0 };
		int nRecv = recv(thisDlg->m_Socket, (char*)buffer, sizeof(buffer), 0);
		if (nRecv <= 0) {		//接收数据失败
			closesocket(thisDlg->m_Socket);										//关闭socket
			thisDlg->GetDlgItem(IDC_LOGIN)->EnableWindow(true);					//启用”登录“按钮
			thisDlg->GetDlgItem(IDC_SEND)->EnableWindow(false);					//禁用“发送”按钮
			AfxMessageBox(_T("服务器失去连接，请稍后再试！"));
			break;
		}
		CString msg(buffer);
		//向对话框发送自定义消息
		::SendMessage(thisDlg->GetSafeHwnd(), WM_UPDATE_MSG, NULL, (LPARAM)&msg);
	}
	return 0;
}

4.对话框自定义消息响应函数

上面的程序向对话框发送了自定义消息，下面就实现在对话框类中接收消息并处理

(1)消息宏的定义。在ChatClientDlg.h文件的开始部分加入消息宏定义，代码如下：

#define WM_UPDATE_MSG WM_USER+100

(2)添加消息响应函数。在CCHatServerDlg类中添加消息响应函数的声明，代码如下：

LRESULT OnUpdateMsg(WPARAM w, LPARAM l);

在ChatClientDlg.cpp文件中给出OnUpdateMsg()函数的定义，代码如下：

//自定义消息响应函数，将参数l中的信息显示在m_edtMsg中
LRESULT CChatClientDlg::OnUpdateMsg(WPARAM w, LPARAM l) {
	CString* strMsg = (CString*)l;
	int len = m_edtMsg.GetWindowTextLength();
	m_edtMsg.SetSel(len, len);
	m_edtMsg.ReplaceSel(*strMsg + _T("\r\n"));
	return 0;
}

需要显示在对话框中的消息由函数的第二个参数传入，将该消息的内容追加在编辑框原来的内容之后

(3)完成消息映射。在ChatClientDlg.cpp文件中，找到BEGIN_MESSAGE_MAP(CChaClientDlg,CDialogEx)和END_MESSAGE_MAP()之间的代码块，在这段代码块中加入消息映射。添加消息映射后的代码如下：

BEGIN_MESSAGE_MAP(CChatClientDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_LOGIN, &CChatClientDlg::OnClickedLogin)
	ON_MESSAGE(WM_UPDATE_MSG,OnUpdateMsg)
	ON_BN_CLICKED(IDC_SEND, &CChatClientDlg::OnClickedSend)
	ON_BN_CLICKED(IDC_EXIT, &CChatClientDlg::OnClickedExit)
END_MESSAGE_MAP()

5.客户端发送信息

为“发送”按钮添加消息响应函数，在函数中添加如下代码：

void CChatClientDlg::OnClickedSend()
{
	// TODO: 在此添加控件通知处理程序代码
	UpdateData(true);
	TCHAR buffer[256] = { 0 };
	_tcscpy_s(buffer, 256, m_strSend);
	if (_tcslen(buffer) == 0) {
		return;
	}
	int len = send(m_Socket, (char*)buffer, _tcslen(buffer) * sizeof(TCHAR), 0);
	if (len < 0) {		//发送失败，与接收失败处理相同
		closesocket(m_Socket);										//关闭socket
		GetDlgItem(IDC_LOGIN)->EnableWindow(true);					//启用”登录“按钮
		GetDlgItem(IDC_SEND)->EnableWindow(false);					//禁用“发送”按钮
		AfxMessageBox(_T("服务器失去连接，请稍后再试！"));
	}
	m_strSend = "";
	UpdateData(false);
}

首先将发送文本框的内容复制到buffer缓冲区，如果内容为空，则返回；如果不为空，调用send()函数向服务器发送buffer的内容

如果发送失败，则关闭socket，启用”登录“按钮，禁用”发送“按钮，并显示“服务器失去连接，稍后再试！”的消息框。

最后将文本框清空。

1.5完善其他功能

1.完善客户端程序

客户端需要完善的程序有退出程序的功能以及析构函数要完成的一些清理工作

(1)添加“退出程序”按钮的消息响应函数。使用类向导添加“退出程序”按钮的消息响应函数，在函数中添加如下代码：

void CChatClientDlg::OnClickedExit()
{
	// TODO: 在此添加控件通知处理程序代码
	CDialogEx::OnCancel();
}

(2)完善对话框类的析构函数。在CChatClientDlg类的析构函数中，添加如下代码：

CChatClientDlg::~CChatClientDlg() {
	if (m_Socket != INVALID_SOCKET)
		closesocket(m_Socket);
}

如果m_Socket不是INVALID_SOCKET，则将其关闭释放资源。

2.完善服务端程序

服务器端需要完善的程序与客户端类似，也是退出程序的功能以及析构函数的要完成的一些清理工作

(1)添加”退出程序“按钮的消息响应函数。使用类向导添加”退出程序“按钮的消息响应函数，在函数中添加如下代码：

void CChatServerDlg::OnClickedExit()
{
	// TODO: 在此添加控件通知处理程序代码
	CDialogEx::OnCancel();
}

(2)完善对话框类的析构函数。在CChatClientDlg类的析构函数中，添加如下代码：

CChatServerDlg::~CChatServerDlg() {
	if (m_listenSocket != INVALID_SOCKET)
		closesocket(m_listenSocket);		//关闭监听socket
	vector <ClientItem*>::iterator it;
	for (it = m_clients.begin(); it != m_clients.end(); ++it) {
		ClientItem* pClient = *it;
		delete pClient;					//将向量中每个元素指定的对象删除
	}	
	m_clients.clear();					//将向量中的元素删除
}

首先将监听socket关闭，然后删除vector的m_clients中的所有元素。

删除向量m_clients中的所有元素分为两个步骤，第一步通过循环将每个元素指向的对象删除，第二步将所有元素移除。

至此聊天室程序全部完成，可以编译运行，查看程序运行效果。