用select模式收发处理数据（跨平台）

最新推荐文章于 2024-05-26 21:18:04 发布
最新推荐文章于 2024-05-26 21:18:04 发布
阅读量4.5k 收藏 7
点赞数
CC 4.0 BY-SA版权
分类专栏： 网络/协议 C/C++ Win32/VC Linux 文章标签： 跨平台 socket struct header server tcp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chexlong/article/details/6723455
本Demo程序展示了C/S架构下使用TCP/IP协议传输数据的基本流程，包括客户端和服务端的Socket初始化、远程地址设定、协议选择（UDP或TCP）、创建连接、发送登录请求和接收服务端响应等关键步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

   本Demo程序模拟C/S传输数据。采用select模式，分别实现了一个客户端小程序和服务端小程序。已在VC2005和Fedroa 13下测试通过。因时间有限，功能简单，欢迎交流，学习！

 

main.cpp

#include "Sock.h"

/*
*
* 传输数据格式
*  ___________ _____________
* |           |             |
* | 32字节头   | 负载数据     |
* |___________|_____________|
*
* 其中32位头中：
* 第0个字节为数据包起始标志：0xCC
* 第1个字节为命令字
* 第4个字节为负载数据长度
* 其余字节填0
*
*/

int main(int argc, char* argv[])
{
	int nRet;
	Sock g_sock;
	char szBuf[1024];

	//初始化Socket环境
	nRet = g_sock.StartUp();
	if (nRet < 0)
	{
		cout<<endl<<"main::init system error"<<endl;
		return 1;
	}

	//客户端
#if defined(_CLIENT_)

	cout<<endl<<"please input s, to start send data : ";

	char ch;
	while (1)
	{
		cin>>ch;
		if ( ch == 's')
		{
			break;
		}
	}

	g_sock.SetRemoteAddr(SERVER_IP, SERVER_PORT);

	if (opMode_udp == g_sock.GetProtocol())
	{
		//创建并绑定本端Socket
		nRet = g_sock.CreateSock(CLIENT_IP, CLIENT_PORT);
		if (nRet < 0)
		{
			cout<<endl<<"main::CreateSock error"<<endl;
			return 1;
		}
	}
	else if (opMode_tcp == g_sock.GetProtocol())
	{
		//创建本端Socket，并连接服务端
		nRet = g_sock.StartConnect(CLIENT_IP, CLIENT_PORT, 5000);
		if (nRet < 0)
		{
			cout<<endl<<"main::StartConnect error"<<endl;
			return 1;
		}
	}

	//向服务端发送登录请求
	memset(szBuf, 0, sizeof(szBuf));
	szBuf[0] = (char)0xCC;
	szBuf[1] = (char)0xA0;
	char *p = "Hello Server!";
	int nExtLen = strlen(p);
	memcpy(szBuf + 4, &nExtLen, sizeof(unsigned int));
	strcpy(szBuf + HEADER_SIZE, p);
	nRet = g_sock.SendData(szBuf, HEADER_SIZE + nExtLen);
	if (nRet < 0)
	{
		cout<<endl<<"main::SendData error"<<endl;
	}
	else
	{
		cout<<endl<<"main::SendData ok"<<endl;
	}


	//接收来自服务端的请求回应，并处理
	nRet = g_sock.RecvData();

	//服务端
#elif defined(_SERVER_)
	
	//创建本端套接字，绑定，并开始侦听
	nRet = g_sock.StartListen(SERVER_IP, SERVER_PORT);
	if (nRet < 0)
	{
		cout<<endl<<"main::StartListen error"<<endl;
		return 1;
	}

	g_sock.SetRemoteAddr(CLIENT_IP, CLIENT_PORT);

	//接收来自客户端的请求，并进行应答处理
	nRet = g_sock.RecvData();

#endif

#ifdef WIN32
	system("pause");
#endif

	//清理socket环境
	g_sock.CleanUp();

	return 0;
}


 

sock.h

 

#ifndef _SOCK_H
#define _SOCK_H

#ifdef WIN32

#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0400
#endif

#define    WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <winsock2.h>

#define EWOULDBLOCK             WSAEWOULDBLOCK
#define EINPROGRESS             WSAEINPROGRESS

#pragma warning(disable:4996)

#else

#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <ctype.h>

#define EWOULDBLOCK EAGAIN

#include <assert.h>

#include <netinet/tcp.h>
#include <semaphore.h>

typedef int SOCKET;
#define INVALID_SOCKET -1
#define closesocket close 

#endif

#include <iostream>
using namespace std;

typedef enum _opMode
{
	opMode_none = 0,
	opMode_tcp,
	opMode_udp
} opMode;

#define HEADER_SIZE 32

#define CLIENT_IP	"127.0.0.1"
#define SERVER_IP	"127.0.0.1"
#define CLIENT_PORT 5678
#define SERVER_PORT 5679


class Sock
{
public:
	Sock(void);
	~Sock(void);

	int SetRemoteAddr(const char* szIp, int nPort);
	int GetProtocol(){return m_nProtocol;}

	int StartUp();
	int CleanUp();

	int CreateSock(const char* szIp = NULL, int nPort = 0);
	int StartListen(const char* szIp, int nPort);
	int StartConnect(const char* szIp, int nPort, int nTimeOut);

	int SendData(char *pszbuf,int nLength);
	int RecvData();
	int TcpRecv();
	int UdpRecv();

	int DealData(char *pData, int nLength);

private:

	unsigned long   m_localIp;
	unsigned short	m_localPort;
	unsigned long	m_remoteIp;	
	unsigned short	m_remotePort;

	int				m_nProtocol;
	SOCKET			m_socket;
	SOCKET			m_clientSock;

	int				m_recvBuffSize;
	int				m_sendBuffSize;

	int				m_bExitRecv;
};


#endif

Sock.cpp

#include "Sock.h"

Sock::Sock(void)
{
	m_remoteIp	= INADDR_ANY;
	m_remotePort= 0;
	m_localIp	= INADDR_ANY;
	m_localPort	= 0;
	m_socket = INVALID_SOCKET;
	m_clientSock = INVALID_SOCKET;

	m_recvBuffSize = 4 * 1024;
	m_sendBuffSize = 4 * 1024;

	m_bExitRecv = false;

	m_nProtocol = opMode_udp;
}

Sock::~Sock(void)
{
}

int Sock::SetRemoteAddr(const char* szIp, int nPort)
{
	m_remoteIp = inet_addr(szIp);
	m_remotePort = htons(nPort);

	return 1;
}

int Sock::StartUp()
{
#ifdef WIN32
	WSADATA wsa = {0};
	int ret = WSAStartup(MAKEWORD(2,2), &wsa);
	if (ret != 0)
	{
		return -1;
	}
#endif
	return 1;
}

int Sock::CleanUp()
{
#ifdef WIN32
	if (WSACleanup() == SOCKET_ERROR)
	{
		return -1;
	}
#endif
	return 1;
}

int	Sock::CreateSock(const char* szIp, int nPort)
{
	if (m_socket != INVALID_SOCKET)
	{
		return -1;
	}

	//创建套接字
	if (opMode_tcp == m_nProtocol)
	{
		m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	}
	else if (opMode_udp == m_nProtocol)
	{
		m_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	}
#ifdef WIN32
	errno = WSAGetLastError();
#endif
	if (m_socket == INVALID_SOCKET)
	{
		return -1;
	}

	int nBlock = 1; //设为非阻塞模式
	int nRet;
#ifdef WIN32
	nRet = ::ioctlsocket(m_socket,FIONBIO,(u_long FAR *)&nBlock);
	if (nRet == SOCKET_ERROR) 
	{
		errno = ::WSAGetLastError();
		nRet = -1;
	}
#else
	nBlock = ::fcntl(m_socket, F_GETFL, 0);
	if (nBlock != -1)
	{
		nBlock |= O_NONBLOCK;
		nRet = ::fcntl(m_socket, F_SETFL, nBlock);
	}
#endif
	if ( -1 == nRet )
	{
		closesocket(m_socket); 
		m_socket = INVALID_SOCKET;
		return -1;
	}

	if (szIp == NULL)
	{
		m_localIp = INADDR_ANY;
	}
	else
	{
		m_localIp = inet_addr(szIp);
	}

	m_localPort = htons(nPort);

	//绑定套接字端口
	if (m_localPort != 0)
	{
		struct sockaddr_in local_addr;
		memset(&local_addr, 0, sizeof(struct sockaddr_in));
		local_addr.sin_family = AF_INET;
		local_addr.sin_port = m_localPort;
		local_addr.sin_addr.s_addr = m_localIp;

		if (INVALID_SOCKET == bind(m_socket, (struct sockaddr *)&local_addr, sizeof(struct sockaddr)))
		{
			closesocket(m_socket);
			m_socket = INVALID_SOCKET;
			return -1;
		}
	}
	else if (opMode_udp == m_nProtocol)
	{
		//随机绑定
		struct sockaddr_in local_addr;
		memset(&local_addr, 0, sizeof(struct sockaddr_in));
		local_addr.sin_family = AF_INET;

		if ( '\0' == szIp[0] )
		{
			local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
		}
		else
		{
			local_addr.sin_addr.s_addr = inet_addr(szIp);
		}

		int n;
		for (n = 0; n < 10000; n++)
		{
			local_addr.sin_port = htons(nPort + n);
			if ( 0 == bind(m_socket, (struct sockaddr*)&local_addr, sizeof(local_addr)) )
			{
				break;
			}
		}

		if (10000 == n)
		{
			closesocket(m_socket);
			m_socket = INVALID_SOCKET;
			return -1;
		}

	}

	//设置套接字接收和发送缓冲区大小
	if(m_recvBuffSize > 0)
		setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (char*)&m_recvBuffSize, sizeof(int));
	if(m_sendBuffSize > 0)
		setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (char*)&m_sendBuffSize, sizeof(int));

	return 1;

}

int Sock::StartListen(const char* szIp, int nPort)
{
	int nRet = CreateSock(szIp, nPort);
	if ( nRet < 0 )
	{
		return -1;
	}

	if (opMode_tcp == m_nProtocol)
	{
		listen(m_socket,5);
	}

	return 1;
}

int Sock::StartConnect(const char* szIp, int nPort, int nTimeOut)
{
	int nRet = CreateSock(szIp, nPort);
	if (nRet < 0)
	{
		return -1;
	}

	struct sockaddr_in remote_addr;
	memset(&remote_addr, 0, sizeof(remote_addr));

	remote_addr.sin_family = AF_INET;
	remote_addr.sin_addr.s_addr = m_remoteIp;
	remote_addr.sin_port = m_remotePort;

	//连接服务端
	nRet = connect(m_socket, (struct sockaddr *)&remote_addr, sizeof(struct sockaddr));
#ifdef WIN32
	if ( SOCKET_ERROR == nRet && (errno = WSAGetLastError()) == EWOULDBLOCK)
	{
#else
	if ( -1 == nRet && EINPROGRESS == errno )
	{
		errno = EWOULDBLOCK; 
#endif

		fd_set fdwrite;
		FD_ZERO(&fdwrite);
		FD_SET(m_socket,&fdwrite);
		timeval tv;
		tv.tv_sec = nTimeOut/1000;
		tv.tv_usec = nTimeOut%1000;
		nRet = select(m_socket + 1, NULL, &fdwrite, NULL, &tv);
#ifdef WIN32
		if ( SOCKET_ERROR == nRet )
		{
			errno = WSAGetLastError();
			closesocket(m_socket);
			m_socket = INVALID_SOCKET;
			return -1;
		}
#else
		if ( -1 == nRet )
		{
			closesocket(m_socket);
			m_socket = INVALID_SOCKET;
		    return -1;
		}
#endif
		if ( 0 == nRet ) //超时
		{
			closesocket(m_socket);
			m_socket = INVALID_SOCKET;
			return -1;
		}
	}
	else
	{
		closesocket(m_socket);
		m_socket = INVALID_SOCKET;
		return -1;
	}

	return 1;
}

int Sock::SendData(char *pszbuf,int nLength)
{
	if (!pszbuf)
	{
		return -1;
	}

	int nRet;
	if (opMode_tcp == m_nProtocol)
	{
#if defined(_CLIENT_)
		nRet = send(m_socket,pszbuf,nLength,0);
#elif defined(_SERVER_)
		nRet = send(m_clientSock,pszbuf,nLength,0);
#endif
	}
	else if (opMode_udp == m_nProtocol)
	{
		sockaddr_in remote_addr;
		remote_addr.sin_family = AF_INET;
		remote_addr.sin_addr.s_addr = m_remoteIp;
		remote_addr.sin_port = m_remotePort;
		nRet = sendto(m_socket,pszbuf,nLength,0,(sockaddr*)&remote_addr,sizeof(remote_addr));
	}

	if (nRet != nLength)
	{
		cout<<endl<<"Sock::SendData socket error.";
		return -1;
	}
	else
	{
		cout<<endl<<"Sock::SendData send data ok.";
	}

	return 1;
}

int Sock::RecvData()
{
	int nRet;
	if (opMode_udp == m_nProtocol)
	{
		nRet = UdpRecv();
	}
	else if (opMode_tcp == m_nProtocol)
	{
		nRet = TcpRecv();
	}

	return 1;
}

int Sock::TcpRecv()
{
	int fds,nRet;
	int nNeeRecvLen = 0,nRecvLen = 0, ntmpLen = 0;
	timeval tv;
	char szbuf[1024*4];
	int iTotal;
	fd_set fd_recv;
	FD_ZERO(&fd_recv);
	sockaddr_in addr;
	int iAddrSize = sizeof(addr);
	SOCKET tmpSock;

	while (true)
	{
		if (m_bExitRecv)
		{
			break;
		}

		tv.tv_sec = 0;
		tv.tv_usec = 100000;
		//memset(szbuf,0,sizeof(szbuf));
		fds = 0;
		FD_ZERO(&fd_recv);
		FD_SET(m_socket,&fd_recv);
		fds = m_socket;
#ifdef _SERVER_
		if (INVALID_SOCKET != m_clientSock)
		{
			FD_SET(m_clientSock,&fd_recv);
			if (m_clientSock > m_socket)
			{
				fds = m_clientSock;
			}
		}
#endif

		if ( fds <=0 )
		{
#ifdef WIN32
			Sleep(1);
#else
			sleep(1);
#endif
			continue;
		}
		iTotal = select(fds + 1, &fd_recv, 0, 0, &tv);

#ifdef WIN32
		if ( SOCKET_ERROR == iTotal )
		{
			errno = WSAGetLastError();
			cout<<endl<<"Sock::TcpRecv socket error = "<<errno;
		}
#else
		if ( -1 == iTotal )
		{
			cout<<endl<<"Sock::TcpRecv socket error = "<<errno;
		}
#endif
		if ( iTotal == 0 ) //超时
		{
			continue;
		}
		if (FD_ISSET(m_socket,&fd_recv) || FD_ISSET(m_clientSock,&fd_recv))//接收
		{
#ifdef _SERVER_
			if (INVALID_SOCKET == m_clientSock)
			{
				m_clientSock = accept(m_socket,(sockaddr*)&addr,
#if !defined(WIN32)
					(socklen_t*)
#endif
					&iAddrSize);
				if ( INVALID_SOCKET == m_clientSock ) //错误
				{
#ifdef WIN32
					errno = WSAGetLastError();
#endif
					cout<<endl<<"Sock::TcpRecv socket error = "<<errno;
				}
				else
				{
					int nRet;
					nRet = setsockopt(m_clientSock, SOL_SOCKET, SO_RCVBUF, (char*)&m_recvBuffSize, sizeof(m_recvBuffSize));
					nRet = setsockopt(m_clientSock, SOL_SOCKET, SO_SNDBUF, (char*)&m_sendBuffSize, sizeof(m_sendBuffSize));
					int nBlock = 1;
#ifdef WIN32
					nRet = ::ioctlsocket(m_clientSock,FIONBIO,(u_long FAR *)&nBlock);
					if (nRet == SOCKET_ERROR) 
					{
						errno = ::WSAGetLastError();
						nRet = -1;
					}
#else
					nBlock = ::fcntl(m_clientSock, F_GETFL, 0);
					if (nBlock != -1)
					{
						nBlock |= O_NONBLOCK;
						nRet = ::fcntl(m_clientSock, F_SETFL, nBlock);
					}
#endif
					if ( -1 == nRet )
					{
						cout<<endl<<"Sock::TcpRecv socket error = "<<errno;
					}
				}
				continue;
			}
			else
			{
				tmpSock = m_clientSock;
			}
#else
		tmpSock = m_socket;
#endif

		if ( 0 == nNeeRecvLen ) //接收消息32位头
		{
			nNeeRecvLen = HEADER_SIZE;
			nRecvLen = recv(tmpSock, szbuf, nNeeRecvLen, 0);
#ifdef WIN32
			if ( SOCKET_ERROR == nRecvLen )
			{
				errno = WSAGetLastError();
				if ( EWOULDBLOCK == errno )
				{
#else
			if ( -1 == nRecvLen )
			{
				if ( EAGAIN == errno )
				{
					errno = EWOULDBLOCK;
#endif
				}
				else 
				{
					cout<<endl<<"Sock::TcpRecv socket error = "<<errno;
				}
			
			}
			else if ( nRecvLen == 0 ) //套接字关闭
			{
				continue;
			}
			else
			{
				int nExtLen = (unsigned int)szbuf[4];
				if (nExtLen > 0)
				{
					nNeeRecvLen = nExtLen;
					ntmpLen = nRecvLen;
				}
			}
		}
		else //接收消息扩展数据
		{
			nRecvLen = recv(tmpSock, szbuf+ntmpLen, nNeeRecvLen, 0);
#ifdef WIN32
			if ( SOCKET_ERROR == nRecvLen )
			{
				errno = WSAGetLastError();
				if ( EWOULDBLOCK == errno )
				{
#else
			if ( -1 == nRecvLen )
			{
				if ( EAGAIN == errno )
				{
					errno = EWOULDBLOCK;
#endif
				}
				else 
				{
					cout<<endl<<"Sock::TcpRecv socket error = "<<errno;
				}

			}
			else if ( nRecvLen == 0 ) //套接字关闭
			{
				continue;
			}
			else
			{
				if (nNeeRecvLen == nRecvLen)
				{
					szbuf[nRecvLen] = '\0';
					//处理数据
					DealData(szbuf, nRecvLen+ntmpLen);
					nNeeRecvLen = 0;
					ntmpLen = 0;
				}
			}
		}

		}

	}

	if (m_socket)
	{
		closesocket(m_socket);
		m_socket = INVALID_SOCKET;
	}
	if (m_clientSock)
	{
		closesocket(m_clientSock);
		m_clientSock = INVALID_SOCKET;
	}
	
	return 1;
}

int Sock::UdpRecv()
{
	int fds,nRet;
	timeval tv;
	char szbuf[1024*4];
	int iTotal;
	fd_set fd_recv;
	FD_ZERO(&fd_recv);
	sockaddr_in addr;
	int iAddrSize = sizeof(addr);

	while (true)
	{
		if (m_bExitRecv)
		{
			break;
		}

		tv.tv_sec = 0;
		tv.tv_usec = 100000;
		memset(szbuf,0,sizeof(szbuf));
		fds = 0;
		FD_ZERO(&fd_recv);
		FD_SET(m_socket,&fd_recv);
		fds = m_socket;

		if ( fds <=0 )
		{
#ifdef WIN32
			Sleep(1);
#else
			sleep(1);
#endif
			continue;
		}
		iTotal = select(fds + 1, &fd_recv, 0, 0, &tv);

#ifdef WIN32
		if ( SOCKET_ERROR == iTotal )
		{
			errno = WSAGetLastError();
			cout<<endl<<"Sock::UdpRecv socket error = "<<errno;
		}
#else
		if ( -1 == iTotal )
		{
			cout<<endl<<"Sock::UdpRecv socket error = "<<errno;
		}
#endif
		if ( iTotal == 0 ) //超时
		{
			continue;
		}

		if ( FD_ISSET(m_socket,&fd_recv) )//接收
		{
			bool bCanRecv = true;
			while ( bCanRecv )
			{
			
				iAddrSize = sizeof(addr);
				nRet = recvfrom(m_socket,szbuf,sizeof(szbuf),0,
					(struct sockaddr*)&addr,
#if !defined(WIN32)
					(socklen_t*)
#endif
					&iAddrSize);
#ifdef WIN32
				if ( SOCKET_ERROR == nRet )
				{
					errno = WSAGetLastError();
					if ( EWOULDBLOCK == errno )
					{
#else
				if ( -1 == nRet )
				{
					if ( EAGAIN == errno )
					{
						errno = EWOULDBLOCK;
#endif
					}
					else //error
					{
						cout<<endl<<"Sock::UdpRecv socket error = "<<errno;
					}
					
					bCanRecv = false;
				}
				else
				{
					//处理数据
					DealData(szbuf, nRet);
				}
			}
		}
	}

	if (m_socket)
	{
		closesocket(m_socket);
		m_socket = INVALID_SOCKET;
	}

	return 1;
}


int Sock::DealData(char *pData, int nLength)
{
	int nExtLen = 0;
	char szBuf[1024];
	memset(szBuf, 0, sizeof(szBuf));
	if (0xA0 == (unsigned char)pData[1])//服务端收到来自客户端的登录请求
	{
		nExtLen = (unsigned int)pData[4];
		memcpy(szBuf, pData+HEADER_SIZE, nExtLen);
		cout<<endl<<"receive data : "<<szBuf;

		memset(szBuf,0,sizeof(szBuf));
		szBuf[0] = (char)0xCC;
		szBuf[1] = (char)0xA1; //登录请求应答
		char *p = "Hello client!";
		nExtLen = strlen(p);
		memcpy(szBuf + 4, &nExtLen, sizeof(unsigned int));
		strcpy(szBuf + HEADER_SIZE, p);
		SendData(szBuf, HEADER_SIZE + nExtLen);
	}
	else if (0xA1 == (unsigned char)pData[1])//客户端收到来自服务端的登录请求应答
	{
		nExtLen = (unsigned int)pData[4];
		memcpy(szBuf, pData+HEADER_SIZE, nExtLen);
		cout<<endl<<"receive data : "<<szBuf;

		memset(szBuf,0,sizeof(szBuf));
		szBuf[0] = (char)0xCC; //发送退出请求
		szBuf[1] = (char)0xB0;
		char *p = "Hello Server, exit now";
		nExtLen = strlen(p);
		memcpy(szBuf + 4, &nExtLen, sizeof(unsigned int));
		strcpy(szBuf + HEADER_SIZE, p);
		SendData(szBuf, HEADER_SIZE + nExtLen);

		m_bExitRecv = true;//本端退出
	}
	else if (0xB0 == (unsigned char)pData[1]) //服务端收到来自客户端的退出请求
	{
		m_bExitRecv = true;//服务端退出
	}

	return 1;
}


下边是Win32和Linux上的截图

 

 

 

 

  

IO多路复用-select的使用详解【C语言】
qq_42037383的博客
07-21 1389
IO多路转接也称为IO多路复用，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。通过这种方式在单线程/进程的场景下也可以在服务器端实现并发。常见的IO多路转接方式有：select、poll、epoll。
C++ 百万并发网络通信引擎架构与实现 （Socket、全栈、跨平台） Version 1.0-张立铜-专题视频课程...
qq_26280299的专栏
10-18 3450
本课程由刘远东、张立铜两位工程师将两人在企业多年积累的开发经验结合而成。从基础的网络知识开始由浅入深地讲解如何使用C++实现一套支持百万级别并发的网络通信引擎。包含：高频并发、多线程、多进程、线程池、内存池、软件硬件瓶颈、如何测试优化网络处理能力等技术知识。可以应用在Windows、Linux、Android、IOS系统上。对从事高性能网络处理的前后端开发人员有极大帮助。咨询群：648738912...
跨平台socket封装
04-12
NULL 博文链接：https://chuqq.iteye.com/blog/1698875
尝试新思路——跨平台Select模型
declarefly的专栏
12-05 580
Select模型
select模型跨平台服务端/客户端
优快云_dzh的博客
05-08 516
最近跟着刘远东老师的《C++百万并发网络通信引擎架...
select跨平台（windows/linux）底层实现区别和陷阱
wangrenhaioylj的博客
08-16 998
目的： 说到select大家可能都很熟悉了，但是在使用过程中还是会有一些比较隐蔽的坑，这篇文章主要是讲一下在使用select实现跨平台通讯库组件的过程中，遇到的因为不同平台（windows、linux）间select底层实现差异导致一个莫名其妙崩溃。 问题描述： linux平台用select实现的网络通讯库在高并发的情况下莫名其妙的崩溃，windows平台却没有任何问题，经过阅读linux fd_set数据结构找到了答案，描述如下： windows、linux平台fd_set数据结构： 1 windows平
html表单传送数据select,Django forms表单 select下拉框的传值实例
weixin_42367947的博客
06-05 630
今儿继续做项目，学习了Django的forms生成前端的代码。forms.pyclass SignupForm(forms.Form):username = forms.CharField(validators=[user_unique_validate, username_rule_validate, ], required=True,max_length=30, min_length=5,er...
一种普通I/O模拟收发数据源代码
10-08
8. **跨平台性**：普通I/O接口在大多数操作系统上都有支持，使得基于此方法的代码具有较好的跨平台性。但是，具体实现可能需要针对不同平台进行调整，以确保兼容性。 9. **安全性**：在模拟I/O通信中，数据安全同样...
7. C++通过select的方式实现高性能网络服务器
最新发布
weixin_45842249的博客
05-26 554
阻塞IO指的是用户程序将IO请求提交后,无需等待IO操作的完成,而是可以继续处理别的事情。所谓阻塞IO，是指以事件触发的机制来对IO操作进行处理。与多进程和多线程技术相比，阻塞I/O技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。我们举个例子吧：假如说我们要去读一个数据，我们要发生系统调用，然后去询问IO是否准备好了，对于阻塞I/O，如果没有准备好的话，他就会一直等，一直等，直到他准备好了。然后再进行下一步操作。
跨平台开发：Linux C语言聊天程序在Windows下的实现
从给出的信息中，我们...开发者需要掌握跨平台开发技巧，熟练使用C语言进行高效编程，理解网络通信的基本原理，能够应用适当的设计模式提升代码质量，并且通过明确的文档和代码模块划分，确保程序的可读性和可维护性。
C++ socket 基本功能跨平台封装（好用）
12-06
真正可以使用的平台无关性的 C++ socket wrapper，没有做任何多余的事情，仅仅对 socket 的基本功能进行了平台无关性的封装，简洁原生。封装了：setoption, connect, close, send, recv, sendto, recvfrom， accept，bind 等基本方法。C++11 标准，macos/linux/windows 均进行了完全测试。
基于select的Linux串口485读写，文件描述符 fd_set
02-05
基于linux ，使用select检测串口句柄事件，同时进行超时判断的串口485读写操作。为高效可控的linux串口操作例程。tcsetattr，tcflush，select，ioctl，gettimeofday。485收发方向切换。
select模型构造发送队列，保证tcp数据发送可靠性
03-25
采用select模型，服务器发送数据产生一个数据队列，客户端接收到后返回服务器接收成功，保证tcp服务的最大可靠性，不可能产生丢失数据现象。
select函数实现一个服务器与多个客户端的通信
12-06
利用select函数实现I/O复用，可进行一个服务器与多个客户端的通信。-CSU某课内作业
Linux网络编程：使用select函数实现socket 收发数据
weixin_41666796的博客
03-15 666
原文链接：https://blog.youkuaiyun.com/li_wen01/article/details/55004918 所谓的回射是指：客户端A向服务端B发送数据，服务端B接收到数据之后，再将接收到的数据发送回客户端B。所谓的迭代服务器，是指服务器端只用一个进程处理或线程处理所有客户端的请求。与之对应的是并发服务器，并发服务器是指对于每一一个客户端的请求，服务端都分配一个进程或是线程独立来处理客...
windows网络编程，TCP/IP协议，UDP/IP协议
01-20
适用人群windows网络编程的初学者课程概述课程简介：这部教程是windows网络编程，包括两部分：tcp/ip协议编程与udp/ip协议编程课程内容：c/s模型的编码，5种windows网络模型：select，异步选择，事件选择，重叠io，完成端口，以及基础理论知识的讲解。课程代码会带大家一行一行书写，让大家都能够学会。课程适合人群：网络编程爱好者，网络编程初学者tcp/ip协议课程章节：第一章 c/s模型的讲解以及代码实现第二章 select模型的讲解以及代码实现第三章 异步选择模型的讲解以及代码实现第四章 事件选择模型的讲解以及代码实现第五章 重叠i/o模型的讲解以及代码实现第六章 完成端口模型的讲解以及代码实现第七章 tcp/ip基础知识的讲解，包括网络分层，三次握手，四次挥手，协议头等等。udp/ip协议课程章节：第一章 c/s模型的讲解以及代码实现第二章 select模型的讲解以及代码实现第三章 异步选择模型的讲解以及代码实现第四章 事件选择模型的讲解以及代码实现第五章 重叠i/o模型的讲解以及代码实现第六章 完成端口模型的讲解以及代码实现
用select函数实现服务器接收，发送，监测功能的同时进行与客户端的收发同时进行。
Huge_Whale的博客
01-03 761
select代替实现多进程多线程中的多任务运行
C#实现串口16进制数据收发应用方案
4. **跨平台**：.NET Core允许C#跨平台运行，而.NET Framework则主要用于Windows平台。 5. **语言集成查询（LINQ）**：允许在多种数据源（如数组、数据库）上进行查询操作。 6. **异步编程**：使用async和await...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

玉古云投

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值