TCP 完成端口服务器构建

秒速五厘米 2022-09-18 12:44 191阅读 0赞

在vs2008中编译通过，vs2010应该也没有问题。

使用静态MFC dll。

其他配置保持默认即可。

可能需要设置/MTD运行时。

可以实现向指定客户端ip发送信息

（该客户端必须首先连接进服务器）

从指定客户端ip中取出数据。

我使用C++类进行了封装，

对各种异常进行了处理。

进行了较详细的注释，

如果有函数不清楚，可以去msdn上查一查。

1，客户端类

#pragma once
    
    #define RECEIVE_SIZE 1024
    /****************************************************
    //Client
    function :
      save info of client
    ***************************************************/
    class Client
    {
    public:
    	Client();
    	~Client();
    public:
    	CCriticalSection	m_cs;
    
    	BYTE				m_pRemainBuf[RECEIVE_SIZE];                 //数据缓存区 
    	BYTE				m_nDataLen;					//数据缓冲区中已有数据的长度
    	BYTE				m_pReceBuf[RECEIVE_SIZE];                   //接受到的数据
    	OVERLAPPED			m_OverLapped;
    
    	WSABUF				m_DataBuf; 
    	SOCKADDR_IN			m_ClientAddress;
    
    	//[!if NET_TYPE_TCP]
    	SOCKET				m_hClientSock;							  //communication socket;
    	//[!endif]
    
    public:
    	//***********将数据存入Client对应的缓冲区中*******************
    	BOOL	SetData(int len);
    
    	//***********从Client对应的缓冲区中取出数据*******************
    	int		GetData(char * buff, int len);
    };

实现：

#include "stdafx.h"
    #include "Client.h"
    
    /****************************************************************************
    *   Name
    Client
    *	Type
    public
    *	Function
    construction function
    *	Return Value
    null
    *	Parameters
    null
    *****************************************************************************/
    Client::Client()
    {
    	//[!if NET_TYPE_TCP]
    	m_hClientSock = INVALID_SOCKET;
    	//[!endif]
    
    	m_nDataLen = 0;
    	memset(m_pRemainBuf, 0, RECEIVE_SIZE);
    	memset(m_pReceBuf,0,RECEIVE_SIZE);
    	memset(&m_OverLapped, 0, sizeof(m_OverLapped));
    }
    
    /****************************************************************************
    *   Name
    ~Client
    *	Type
    public
    *	Function
    
    *	Return Value
    null
    *	Parameters
    null
    *****************************************************************************/
    Client::~Client()
    {
    	int a=0;
    	a=3;
    }
    
    
    //*********************TCP接受数据************************
    //**************缓冲区没有溢出，则将数据追加其后**********
    BOOL Client::SetData( int len )
    {
    	if (len<0)
    	{
    		return FALSE;
    	}
    
    	if (len==0)
    	{
    		return TRUE;
    	}
    
    	m_cs.Lock();
    	if (m_nDataLen+len>=RECEIVE_SIZE)
    	{
    		if (len<RECEIVE_SIZE)
    		{
    			memcpy_s(m_pRemainBuf, RECEIVE_SIZE, m_pReceBuf, len);
    			m_nDataLen = len;
    		}
    		else
    		{
    			memcpy_s(m_pRemainBuf, RECEIVE_SIZE, m_pReceBuf, RECEIVE_SIZE);
    			m_nDataLen = (BYTE)RECEIVE_SIZE;
    		}
    	}
    	else
    	{
    		memcpy_s(m_pRemainBuf + m_nDataLen, RECEIVE_SIZE-m_nDataLen, m_pReceBuf, len);
    		m_nDataLen += len;
    	}
    
    	m_cs.Unlock();
    
    	return TRUE;
    }
    
    
    int Client::GetData( char * buff, int len )
    {
    	if (!buff)
    	{
    		return 0;
    	}
    
    	int result=0;
    	m_cs.Lock();
    	if (m_nDataLen <= len)
    	{
    		memcpy_s(buff, len, m_pRemainBuf, m_nDataLen);
    		result = m_nDataLen;
    		m_nDataLen = 0;
    	}
    	else
    	{
    		memcpy_s(buff, len, m_pRemainBuf, len);
    		memmove_s(m_pRemainBuf, RECEIVE_SIZE, m_pRemainBuf + len, m_nDataLen-len);
    		m_nDataLen -= len;
    		result = len;
    	}
    	
    	m_cs.Unlock();
    	return result;
    }

2，TCP完成端口的封装

头文件：

/************************************************************************/
    //* 文件名称: IOCP_TCP.h
    //* 文件标示:
    //* 摘    要:采用完成端口技术处理网络数据
    //*
    //* 当前版本:1.0
    //* 作    者:hxy
    //* 完成日期:2013-11-16
    //*
    /************************************************************************/
    #ifndef  _COMPLETIONPORT_H__
    #define  _COMPLETIONPORT_H__
    
    #include <winsock2.h>
    #include <mswsock.h>
    #include "afxmt.h"
    #include <vector>
    #include "Client.h"
    using namespace std;
    #pragma once
    
    #define MAXTHREAD_COUNT 8
    #define RECEIVE_SIZE  1024
    #define PORT 502
    
    class Client;
    class CompletionPort
    {
    public:
    	CompletionPort();
    	~CompletionPort();
    
    	//************初始化****************************
    	//	参数：  需要绑定的ip和port
    	//	功能：	初始化socket库
    	//			设置需要绑定的ip和port
    	//**********************************************
    	BOOL Init(char * lpszHostAddress, UINT nHostPort);
    
    	//************启动******************************
    	//	功能：	1,启动监听功能; 2,生成完成端口对象
    	//**********************************************
    	BOOL Active(void);
    
    	//************停止******************************
    	//	功能：	停止监听功能，
    	//			释放Active中的申请的所有资源
    	//**********************************************
    	BOOL Close(void);
    
    	//************接受数据**************************
    	//	功能：	接受指定客户端ip的数据
    	//	参数：  buff：指向接受数据的缓冲区
    	//			len:  缓冲区的大小
    	//			ip:	  客户端ip，如192.168.31.27
    	//  说明：  buff的内存由调用者提供
    	//**********************************************
    	int ReceiveData(char * buff, int len, char * ip);
    
    	//************发送数据***************************
    	//	功能：	向指定的客户端ip的数据
    	//	参数：  buff：指向发送数据的缓冲区
    	//			len:  缓冲区的大小
    	//			ip:	  客户端ip，如192.168.31.27
    	//**********************************************
    	int SendData(const char * buff, int len, char * ip);
    
    //-------------------------内部使用--------------------------------
    	//************监听*******************************
    	//	功能：	监听客户端连接线程
    	//***********************************************
    	void MonitorServerSocket();	
    
    	//************监听客户端发送的数据***************
    	//	功能：	监听客户端连接线程函数
    	//***********************************************
    	void MonitorIoCompletionPort();							
    
    	//************处理客户端连接*********************
    	//	功能：	客户端连接处理函数
    	//***********************************************
    	void OnClientAccept();									
    
    	//************处理客户端关闭*********************
    	//	功能：	客户端关闭处理函数
    	//***********************************************
    	BOOL OnClientClose(DWORD dwSockId);
    
    
    private:
    	//************初始化Socket库*********************
    	//	功能：	初始化Socket库
    	//***********************************************
    	BOOL InitWinsock();
    	
    
    	void ProcessData(Client* pClient);
    
    	Client* GetClient(DWORD dwSockId, int& index);
    
    //----------------------------Client 管理-------------------------
    
    	//************增加客户端*********************
    	BOOL AddClient( Client * const pClient);
    
    	//************删除客户端*********************
    	BOOL DeleteClient( int index);
    
    	//************查询客户端*********************
    	Client * GetClient( const char * ip);
    
    
    
    private:
    	
    	SOCKADDR_IN m_HostAddress;							//服务器端地址（ip，port，协议）等
    
    	vector<Client*> m_ClientVector;						//客户端表
    	rec_lock m_cs;								//客户端表同步
    
    	BOOL			m_bIsQuit;							//退出标识
    	HANDLE			m_hQuitEvent;						//退出事件句柄
    	HANDLE			m_hCOP;								//完成端口句柄
    	HANDLE			m_hThreadArray[MAXTHREAD_COUNT];	//接收数据线程句柄
    	int				m_nThreadArray;						//接收数据线程数量
    
    	HANDLE			m_hListen;							//监听连接线程句柄
    	SOCKET			m_ListenSocket;						//监听socket
    
    	BOOL			m_bQuitThread;						//监听线程退出标识
    	WSAEVENT		m_wsaEvent;							//网络事件
    
    
    };
    
    #endif

实现文件：

#include "StdAfx.h"
    #include "IOCP_TCP.h"
    
    #ifdef _DEBUG
    #define new DEBUG_NEW
    #undef THIS_FILE
    static char THIS_FILE[] = __FILE__;
    #endif
    
    /****************************************************************************
    *   Name
    ThreadTcpServer
    *	Type
    public
    *	Function
    thread to monitor a socket and accept a link
    *	Return Value
    DWORD WINAPI
    *	Parameters
    void * lpParameter 
    *****************************************************************************/
    DWORD WINAPI ThreadTcpServer(void * lpParameter)
    {
    	CompletionPort* pCpPort = (CompletionPort*)lpParameter;
    	
    	pCpPort->MonitorServerSocket();
    	return 0;
    }
    
    /****************************************************************************
    *   Name
    CompletionRoutine
    *	Type
    public
    *	Function
    work thread of completionport 
    *	Return Value
    DWORD WINAPI
    *	Parameters
    void * lpParameter translate a pointer of this
    *****************************************************************************/
    DWORD WINAPI  CompletionRoutine(void * lpParameter)
    {
    	CompletionPort* pCpPort = (CompletionPort*)lpParameter;
    
    	pCpPort->MonitorIoCompletionPort();
    	return 0;
    }
    
    
    /****************************************************************************
    *   Name
    CompletionPort
    *	Type
    public
    *	Function
    constructor
    *	Return Value
    null
    *	Parameters
    null 
    *****************************************************************************/
    CompletionPort::CompletionPort()
    {
    	//_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF| _CRTDBG_LEAK_CHECK_DF); 
    	m_hCOP = INVALID_HANDLE_VALUE;
    	m_hListen = INVALID_HANDLE_VALUE;
    	for (int i=0; i< MAXTHREAD_COUNT; i++)
    	{
    		m_hThreadArray[i] = INVALID_HANDLE_VALUE;
    	}
    	m_bQuitThread = FALSE;
    	m_wsaEvent = NULL;
    	m_ListenSocket = INVALID_SOCKET;
    	m_ClientVector.clear();
    	m_bIsQuit = FALSE;
    	m_hQuitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    	m_nThreadArray = 0;
    }
    
    /****************************************************************************
    *   Name
    ~CompletionPort
    *	Type
    public
    *	Function
    do sth to release memory
    *	Return Value
    null
    *	Parameters
    null 
    *****************************************************************************/
    CompletionPort::~CompletionPort()
    {
    	int i = 0;
    	m_bIsQuit = TRUE;
    	Sleep(10);
    	if (INVALID_HANDLE_VALUE != m_hCOP)
    	{
    		m_bIsQuit = TRUE;
    		//等待所有接受数据的线程结束
    		WaitForMultipleObjects(m_nThreadArray, m_hThreadArray, TRUE, INFINITE); 
    		while (INVALID_HANDLE_VALUE != m_hThreadArray[i])
    		{
    			CloseHandle(m_hThreadArray[i]);
    			m_hThreadArray[i-1] = INVALID_HANDLE_VALUE;
    			i++;
    		}
    		//关闭完成端口
    		CloseHandle(m_hCOP);
    		m_hCOP=NULL;		
    	}
    
    	// 关闭监听socket
    	if (INVALID_SOCKET != m_ListenSocket)
    	{
    		closesocket(m_ListenSocket);
    		m_ListenSocket = NULL;
    	}
    	
    	// 关闭监听线程
    	m_bQuitThread = TRUE;
    	WaitForSingleObject(m_hListen, INFINITE);
    	if (INVALID_HANDLE_VALUE != m_hListen)
    	{
    		CloseHandle(m_hListen);
    		m_hListen = NULL;
    	}
    
    	WSACloseEvent(m_wsaEvent);
    	m_wsaEvent = NULL;
    
    	// 关闭客户端连接socket
    	for( size_t i=0; i<m_ClientVector.size(); i++)
    	{
    		Client* pClient = m_ClientVector[i];
    		if( pClient != NULL)
    		{
    			if (pClient->m_hClientSock != INVALID_SOCKET)
    			{
    				shutdown(pClient->m_hClientSock, 2);
    				closesocket(pClient->m_hClientSock);
    				pClient->m_hClientSock = INVALID_SOCKET;
    			}
    			delete pClient;
    			pClient = NULL;
    		}
    	}
    	CloseHandle(m_hQuitEvent);
    	m_ClientVector.clear();	
    }
    
    
    BOOL CompletionPort::Init(char * lpszHostAddress, UINT nHostPort)
    {
    	if (!InitWinsock())
    	{
    		return FALSE;
    	}
    	
    	m_HostAddress.sin_family = AF_INET;
    
    	m_HostAddress.sin_addr.s_addr = inet_addr((char *)lpszHostAddress);
    
    	if (m_HostAddress.sin_addr.s_addr == INADDR_NONE)
    	{
    		LPHOSTENT lphost;
    		lphost = gethostbyname((char *)lpszHostAddress);
    		if (lphost != NULL)
    			m_HostAddress.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
    		else
    		{
    			WSASetLastError(WSAEINVAL);
    			return FALSE;
    		}
    	}
    
    	m_HostAddress.sin_port = htons((u_short)nHostPort);
    
    	return true;
    }
    
    //************启动******************************
    //	功能：	启动监听功能
    //**********************************************
    BOOL CompletionPort::Active()
    {
    
    //-------------------------------监听连接---------------------------------------
    	//创建监听Socket
    	m_ListenSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED); 
    	if (INVALID_SOCKET == m_ListenSocket)
    	{
    		return FALSE;
    	}
    
    	int nResult = bind(m_ListenSocket, (PSOCKADDR)&m_HostAddress, sizeof(m_HostAddress));
    	if (SOCKET_ERROR == nResult)
    	{
    		closesocket(m_ListenSocket);        
    		return FALSE;
    	}
    
    	nResult = listen(m_ListenSocket, 20);
    	if (SOCKET_ERROR == nResult)
    	{
    		closesocket(m_ListenSocket);
    		return FALSE;
    	}
    
    	m_wsaEvent = WSACreateEvent();
    	if (NULL == m_wsaEvent)
    	{
    		return FALSE;
    	}
    
    	WSAEventSelect(m_ListenSocket, m_wsaEvent, FD_ACCEPT);
    
    	//创建监听连接的线程
    	m_hListen = CreateThread(NULL, 0, ThreadTcpServer, (LPVOID)this, 0, NULL);
    	if (NULL == m_hListen)
    	{
    		return FALSE;
    	}
    
    //-------------------------------完成端口---------------------------------------
    	//创建完成端口句柄
    	m_hCOP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0);
    	if (NULL == m_hCOP)
    	{
    		return FALSE;
    	}
    
    	//创建处理数据的线程
    	SYSTEM_INFO SysInfo;
    	GetSystemInfo(&SysInfo);
    	for (int i=0; i<(int)SysInfo.dwNumberOfProcessors && (i<MAXTHREAD_COUNT); i++)
    	{
    		m_hThreadArray[i] = CreateThread(NULL, 0, CompletionRoutine, (LPVOID)this, 0, NULL);
    		if (NULL == m_hThreadArray[i])
    		{
    			while (i>0)
    			{
    				CloseHandle(m_hThreadArray[i-1]);
    				m_hThreadArray[i-1] = INVALID_HANDLE_VALUE;
    				i--;
    			}
    			return FALSE;  
    		}
    		m_nThreadArray ++;
    	}
    	return TRUE;	
    }
    
    //************从完成端口取数据******************
    //	功能： 从完成端口取数据
    //  返回： 字节数，如果ip未连接则返回0
    //**********************************************
    int CompletionPort::ReceiveData(char * buff, int len, char * ip)
    {
    	if (!buff || !ip)
    	{
    		return 0;
    	}
    
    	Client * pClient = GetClient(ip);
    
    	if (!pClient)
    	{
    		return 0;
    	}
    
    	return pClient->GetData(buff, len);
    }
    
    //************发送数据***************************
    //	功能：	向指定的客户端ip的数据
    //	参数：  buff：指向发送数据的缓冲区
    //			len:  要发送的数据的字节数
    //			ip:	  客户端ip，如192.168.31.27
    //  返回：	发送的字节数，错误则返回0
    //**********************************************
    int CompletionPort::SendData(const char * buff, int len, char * ip)
    {
    	if (!buff || !ip)
    	{
    		return 0;
    	}
    
    	int ret =0;
    
    	//在取得客户端指针之后，完成端口线程会删除该客户端，
    	//可能造成最null指针的解引用，所有这里使用结构化异常进行处理
    	__try
    	{
    		Client * pClient = GetClient(ip);
    
    		if (!pClient)
    		{
    			return 0;
    		}
    
    		DWORD result = 0;
    		ret =send(pClient->m_hClientSock, buff, len, 0);
    		//int ret = WriteFile((HANDLE)pClient->m_hClientSock, buff, len, &result, NULL);
    	}
    	__except (EXCEPTION_EXECUTE_HANDLER) 
    	{
    		printf("客户端已被删除，发送失败");
    	}
    	return ret;
    }
    
    /****************************************************************************
    *   Name
    InitWinsock
    *	Type
    public
    *	Function
    initialize socket
    *	Return Value
    BOOL
    *	Parameters
    null 
    *****************************************************************************/
    BOOL CompletionPort::InitWinsock()
    {
    	WSADATA wsd;
    	int nResult = WSAStartup(MAKEWORD(2,2), &wsd);
    	if (0 != nResult)
    	{		
    		return FALSE;
    	}
    	return TRUE;
    }
    
    /****************************************************************************
    *   Name
    MonitorServerSocket
    *	Type
    public
    *	Function
    function to monitor a socket and accept a link
    *	Return Value
    null
    *	Parameters
    null 
    *****************************************************************************/
    void CompletionPort::MonitorServerSocket()
    {
    	DWORD	dwWaitCode;
    	WSANETWORKEVENTS wsaNetWorkEvents;
    	while( true )
    	{
    		if( m_bQuitThread )					//判断监听线程退出条件是否满足
    		{
    			SetEvent(m_hQuitEvent);
    			TRACE("Monitor Server Quit\n");
    			return ;
    		}
    
    		dwWaitCode = WSAWaitForMultipleEvents(1, &m_wsaEvent, FALSE, 2000, FALSE);//等待网络事件
    		if(dwWaitCode != WAIT_OBJECT_0)  
    			continue;
    
    		if( SOCKET_ERROR == WSAEnumNetworkEvents(m_ListenSocket, m_wsaEvent,&wsaNetWorkEvents ))//枚举网络事件
    		{
    			int nErrorCode = WSAGetLastError();
    			TRACE("WSAEnumNetworkEvents Error");
    		}
    		else
    		{
    			if( wsaNetWorkEvents.lNetworkEvents & FD_ACCEPT)
    			{
    				OnClientAccept();
    			}
    		}
    	}
    }
    
    /****************************************************************************
    *   Name
    OnClientAccept
    *	Type
    public
    *	Function
    function to monitor a socket and accept a link
    *	Return Value
    null
    *	Parameters
    null 
    *****************************************************************************/
    void CompletionPort::OnClientAccept()
    {
    	
    	int nSockAddrLength = sizeof(SOCKADDR_IN);
    	Client* pClntData = new Client();
    	pClntData->m_hClientSock = accept(m_ListenSocket,
    						(struct sockaddr*)&(pClntData->m_ClientAddress),
    						&nSockAddrLength);
    
    	if (INVALID_SOCKET == pClntData->m_hClientSock)
    	{
    		delete pClntData;
    	}
    
    	AddClient(pClntData);
    
    	HANDLE hCompletePort = CreateIoCompletionPort((HANDLE)pClntData->m_hClientSock, m_hCOP,
    		(DWORD)pClntData->m_hClientSock,0);
    	if( hCompletePort != m_hCOP)
    	{
    		TRACE("Create Communication CompletionPort failure!\n");
    	}
    
    	ReadFile((HANDLE)pClntData->m_hClientSock, pClntData->m_pReceBuf, RECEIVE_SIZE, NULL, 
    		&pClntData->m_OverLapped);
    }
    
    /****************************************************************************
    *   Name
    MonitorIoCompletionPort
    *	Type
    public
    *	Function
    function to monitor completionport 
    *	Return Value
    void
    *	Parameters
    null
    *****************************************************************************/
    void CompletionPort::MonitorIoCompletionPort()
    {
    	TRACE("Begin Monitor IoPort \n");
    	BOOL  bSuc       = FALSE;
    	DWORD dwNumBytes = 0;
    	DWORD dwKey      = -1;
    	DWORD dwSockId = 0;
    	LPOVERLAPPED completedOverlapped;
    
    	int nLen =0;
    	while( true )
    	{
    		//判断监听线程退出条件是否满足
    		if( m_bIsQuit)
    		{
    			TRACE("Monitor IoCompletionPort Quit\n");
    			SetEvent(m_hQuitEvent);
    			return;
    		}
    		//查询完全端口状态
    		dwKey = -1;
    		bSuc  = GetQueuedCompletionStatus( m_hCOP, &dwNumBytes, &dwKey, &completedOverlapped, 2000);
    		if (bSuc==FALSE)
    		{
    			int nError = WSAGetLastError();
    
    			if (nError == WSA_WAIT_TIMEOUT)
    			{
    				continue;
    			}
    			
    			if (nError == ERROR_NETNAME_DELETED)
    			{
    				OnClientClose(dwKey);
    				continue;
    			}
    			TRACE("GetQueuedCompletionStatus Error: %d\n", nError);
    			continue;
    		}
    
    
    		if (dwKey>0)
    		{
    			dwSockId  = dwKey;
    			nLen = dwNumBytes;
    			if( nLen > 0)
    			{ 
    				int index = -1;
    				Client* pClient = GetClient(dwSockId, index);
    				if( pClient == NULL)  
    					continue;
    				try
    				{
    					//Sleep(50);
    					if (nLen >1024)
    					{
    						nLen = 1024;
    						//CDebug::ShowErroMessage("接收到数据长度过长！");
    					}
    					
    					pClient->SetData(nLen);
    					//ProcessData(pClient);
    
    					//向完全端口发送读指令，等待下一次数据
    					ZeroMemory(pClient->m_pReceBuf,RECEIVE_SIZE);
    			
    					ReadFile((HANDLE)pClient->m_hClientSock,pClient->m_pReceBuf,RECEIVE_SIZE,NULL,&pClient->m_OverLapped);
    		
    
    				}
    				catch(...)
    				{
    					TRACE("catch an error");
    				}		
    			}
    			else
    			{
    				OnClientClose(dwSockId);
    			}
    		}
    	}
    }
    
    /****************************************************************************
    *   Name
    GetClient
    *	Type
    public
    *	Function
    get a pointer to point class of  Client
    *	Return Value
    Client*
    *	Parameters
    DWORD dwSockId : socket ID
    int& index: the position in the vector
    *****************************************************************************/
    Client* CompletionPort::GetClient(DWORD dwSockId, int& index)
    {
    	Client* pNewData = NULL;
    	m_cs.lock();
    	for (size_t i = 0; i < m_ClientVector.size(); i++)
    	{
    		if (m_ClientVector[i]->m_hClientSock == dwSockId)
    		{
    			index = i;
    			pNewData = m_ClientVector[i];
    			break;
    		}
    	}
    	m_cs.unlock();	
    	return pNewData;
    }
    
    /****************************************************************************
    *   Name
    OnClientClose
    *	Type
    public
    *	Function
    close the socket that dont translate data
    *	Return Value
    BOOL
    *	Parameters
    DWORD dwSockId: socket ID
    *****************************************************************************/
    BOOL CompletionPort::OnClientClose(DWORD dwSockId)
    {
    	int index = -1;
    	Client* pClient = GetClient(dwSockId, index);
    	if ((NULL != pClient) && (-1 != index))
    	{
    		closesocket(pClient->m_hClientSock);
    		DeleteClient(index);
    		pClient = NULL;
    	}
    	return TRUE;
    }
    
    //----------------------------Client 管理-------------------------
    
    //************增加客户端*********************
    BOOL CompletionPort::AddClient(Client * const pClient)
    {
    	if (!pClient)
    	{
    		return FALSE;
    	}
    	m_cs.lock();
    	m_ClientVector.push_back(pClient);
    	m_cs.unlock();
    	return TRUE;
    }
    
    //************删除客户端*********************
    BOOL CompletionPort::DeleteClient(int index)
    {
    	m_cs.lock();
    	delete m_ClientVector[index];
    	m_ClientVector.erase(m_ClientVector.begin() + index);
    	m_cs.unlock();
    	return TRUE;
    }
    
    //************查询客户端*********************
    Client * CompletionPort::GetClient(const char * ip)
    {
    	Client* pNewClient = NULL;
    	ULONG nAddr = inet_addr(ip); 
    	m_cs.lock();
    	for (size_t i = 0; i < m_ClientVector.size(); i++)
    	{
    		if (m_ClientVector[i]->m_ClientAddress.sin_addr.s_addr == nAddr)
    		{
    			pNewClient = m_ClientVector[i];
    			break;
    		}
    	}
    	m_cs.unlock();
    	return pNewClient;
    }

3，测试文件：

// IOCPTest.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include "IOCP_TCP.h"
    #include <iostream>
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    
    	CCriticalSection *p = new CCriticalSection;
    	delete p;
    
    	CompletionPort * cp = new CompletionPort();
    	
    	cp->Init("192.168.31.27", 4567);           //需要修改为自己的ip
    	cp->Active();
    	
    	char buff[1024]={0};
    	char recBuff[1024]={0};
    	int len;
    	while (true)
    	{
    		scanf_s("%s", buff, 1023);
    		len = strlen(buff);
    		cp->SendData(buff, len, "192.168.31.27"); //客户端的ip
    		ZeroMemory(recBuff,1024);
    		cp->ReceiveData(recBuff, 1024, "192.168.31.27");     //客户端的ip
    		printf("\n%s\n", recBuff);
    	}
    	delete cp;
    	return 0;
    }

5，预编译头文件

// stdafx.h : include file for standard system include files,
    //  or project specific include files that are used frequently, but
    //      are changed infrequently
    //
    
    #if _MSC_VER > 1000
    #pragma once
    #endif // _MSC_VER > 1000
    
    #define _WIN32_WINNT	0x0501
    
    #define VC_EXTRALEAN		// Exclude rarely-used stuff from Windows headers
    
    #include <afxwin.h>         // MFC core and standard components
    #include <afxext.h>         // MFC extensions
    
    #ifndef _AFX_NO_OLE_SUPPORT
    #include <afxole.h>         // MFC OLE classes
    #include <afxodlgs.h>       // MFC OLE dialog classes
    #include <afxdisp.h>        // MFC Automation classes
    #endif // _AFX_NO_OLE_SUPPORT
    
    
    #ifndef _AFX_NO_DB_SUPPORT
    #include <afxdb.h>			// MFC ODBC database classes
    #endif // _AFX_NO_DB_SUPPORT
    
    #ifndef _AFX_NO_DAO_SUPPORT
    #include <afxdao.h>			// MFC DAO database classes
    #endif // _AFX_NO_DAO_SUPPORT
    
    #include <afxdtctl.h>		// MFC support for Internet Explorer 4 Common Controls
    #ifndef _AFX_NO_AFXCMN_SUPPORT
    #include <afxcmn.h>			// MFC support for Windows Common Controls
    #endif // _AFX_NO_AFXCMN_SUPPORT
    
    //外部库文件引用
    #include <afxmt.h>
    #include <afx.h>
    #include <afxtempl.h>
    
    #include <winsock2.h>
    #include <memory>
    
    //外部自定义头文件引用
    
    //#include "Resource.h"
    //#include "ICOMPro.h"
    //#include "datatype.h"
    //#include "Reg.h"
    //#include "Debug.h"
    //#include "Helper.h"
    
    #if defined(_WIN32_WCE_CEPC) || defined(_ARM_)
    #include "AtomCE.h"
    #endif
    
    
    //编译选项
    
    //[!if TRYCONNECT_TRUE]
    //#define _TRYCONNECT_TRUE
    //[!endif]
    //
    //[!if TRYCONNECT_USERDEFINE]
    //#define _TRYCONNECT_USEDEFINE
    //[!endif]
    //
    //[!if TRYCONNECT_USEPACKET]
    //#define _TRYCONNECT_USEPACKET
    //[!endif]
    //
    //[!if REOPENCOM]
    //#define _REOPENCOM
    //[!endif]
    
    
    
    //{
       {AFX_INSERT_LOCATION}}
    // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
    #include "lock.h"