socket网络编程select使用方法

文章以及源码均为原创，当然欢迎转载，转载请加说明

server.h

//int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout);
//nfds：select监视的文件句柄数
//readfds：select监视的可读文件句柄集合
//writefds: select监视的可写文件句柄集合
//exceptfds：select监视的异常文件句柄集合
//timeout：超时时间，如果timeout == NULL，无期等待
//返回值：
//0：超时
//SOCKET_ERROR：出错
//大于0：fd个数
//
//FD_ZERO(fd_set *fdset)：清空fdset
//FD_SET(int fd, fd_set *fdset)：设置监视
//FD_CLR(int fd, fd_set *fdset)：清除监视
//FD_ISSET(int fd, fd_set *fdset)：检查是否可以读写

#ifndef SERVER_H
#define SERVER_H

#include<iostream>
#include <WS2tcpip.h>
#include <vector>

#pragma comment(lib,"Ws2_32.lib")

#define IPADDRESS   "127.0.0.1"
#define PORT        3300

class CServer
{
public:
	CServer();
	~CServer();

	bool Create(const char* ip, int port);
	void Select();
	void Close();

protected:

private:
	SOCKET m_Listenfd;
	std::vector<SOCKET> m_ClientfdVec;
	fd_set m_ReadSet;
	fd_set m_WriteSet;
	fd_set m_ExceptSet;
};

#endif //SERVER_H

server.cpp

#include"server.h"

CServer::CServer()
{
	m_Listenfd = 0;
	FD_ZERO(&m_ReadSet);
	FD_ZERO(&m_WriteSet);
	FD_ZERO(&m_ExceptSet);
	m_ClientfdVec.clear();
}

CServer::~CServer()
{
	Close();
}

bool CServer::Create(const char* I_Ip, int I_Port)
{
	WORD WVersionRequest = { 0 };
	WSADATA WSaDate = { 0 };
	sockaddr_in ServAddr = { 0 };//服务端地址结构

	//注册协议版本
	WVersionRequest = MAKEWORD(2, 2);
	if (WSAStartup(WVersionRequest, &WSaDate))
	{
		perror("WSAStartup");
		return false;
	}
	printf("WSAStartup ok\n");

	//创建服务端监听socket
	m_Listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (m_Listenfd == SOCKET_ERROR)
	{
		perror("socket");
		return false;
	}
	printf("socket ok\n");

	//设置服务端地址和端口
	ServAddr.sin_family = AF_INET;
	inet_pton(AF_INET, I_Ip, &ServAddr.sin_addr);
	ServAddr.sin_port = htons(I_Port);

	//绑定服务端地址和端口
	if (0 != bind(m_Listenfd, (sockaddr*)&ServAddr, sizeof(ServAddr)))
	{
		perror("bind");
		closesocket(m_Listenfd);
		return false;
	}
	printf("bind ok\n");

	//设置监听
	if (0 != listen(m_Listenfd, 5))
	{
		perror("listen");
		closesocket(m_Listenfd);
		return false;
	}
	printf("listen ok\n");

	return true;
}

void CServer::Select()
{
	SOCKET ClientFd = 0;
	sockaddr_in ClientAddr = { 0 };//客户端地址结构
	TIMEVAL TimeVal;//设置超时等待时间
	TimeVal.tv_sec = 5;
	TimeVal.tv_usec = 0;
	char TempBuf[1024] = "";
	int SockAddrLen = sizeof(sockaddr_in);
	bool CloseFlag = false;
	while (true)
	{
		FD_SET(m_Listenfd, &m_ReadSet);
		for (auto Ite : m_ClientfdVec)
		{
			FD_SET(Ite, &m_ReadSet);
		}
		switch (select(FD_SETSIZE, &m_ReadSet, &m_WriteSet, &m_ExceptSet, &TimeVal))
		{
		case 0:
			printf("超时\n");
			continue;
		case SOCKET_ERROR:
			perror("select");
			continue;
		default:
			if (FD_ISSET(m_Listenfd, &m_ReadSet))
			{
				//接受连接
				ClientFd = accept(m_Listenfd, (sockaddr*)&ClientAddr, &SockAddrLen);
				if (ClientFd == 0)
				{
					perror("accept");
				}
				else
				{
					m_ClientfdVec.push_back(ClientFd);
					printf("客户端%s已连接\n", inet_ntoa(ClientAddr.sin_addr));
				}
			}

			for (auto Ite = m_ClientfdVec.begin(); Ite != m_ClientfdVec.end();)
			{
				if (FD_ISSET(*Ite, &m_ReadSet))
				{
					switch (recv(*Ite, TempBuf, sizeof(TempBuf), 0))
					{
					case 0:
						CloseFlag = true;
						break;
					case SOCKET_ERROR:
						perror("recv");
						CloseFlag = false;
						break;
					default:
						//这里可以开个处理本次消息的新线程，或者用线程池
						std::cout << "接收：" << TempBuf << std::endl;
						FD_SET(*Ite, &m_WriteSet);
						CloseFlag = false;
						break;
					}
				}
				if (FD_ISSET(*Ite, &m_WriteSet))
				{
					strcpy(TempBuf, "servertest");
					if (0 >= send(*Ite, TempBuf, sizeof(TempBuf), 0))
					{
						perror("send");
					}
					else
					{
						printf("发送：%s\n", TempBuf);
						FD_CLR(*Ite, &m_WriteSet);
					}
				}
				if (FD_ISSET(*Ite, &m_ExceptSet))
				{

				}

				if (CloseFlag)
				{
					FD_CLR(*Ite, &m_ReadSet);
					closesocket(*Ite);
					Ite = m_ClientfdVec.erase(Ite);
				}
				else
				{
					Ite++;
				}
			}
		}
	}
}

void CServer::Close()
{
	for (auto Fd : m_ClientfdVec)
	{
		closesocket(Fd);
	}
	m_ClientfdVec.clear();
	closesocket(m_Listenfd);
	WSACleanup();
}

int main()
{
	CServer Server;
	if (Server.Create(IPADDRESS, PORT))
	{
		Server.Select();
		Server.Close();
	}
	system("pause");
	return 0;
}

client.h

#ifndef CLIENT_H
#define CLIENT_H

#include<iostream>
#include <WS2tcpip.h>
#include <vector>
#include <mutex>
#include<conio.h>
#include <string.h>
#include <thread>

#pragma comment(lib,"Ws2_32.lib")

#define IPADDRESS   "127.0.0.1"
#define PORT        3300

class CClient
{
public:
	CClient();
	~CClient();

	bool Create(const char* ip, int port);
	void Select();
	void Close();

protected:

private:
	void GetSendBufHandle();

	SOCKET m_Clientfd;
	fd_set m_ReadSet;
	fd_set m_WriteSet;
	fd_set m_ExceptSet;
	std::mutex m_Mutex;
	std::string m_SendBuf;
	bool m_IsStart;
	std::thread *m_pThread;
};

#endif // !CLIENT_H

client.cpp

#include"client.h"

CClient::CClient()
{
	m_Clientfd = 0;
	FD_ZERO(&m_ReadSet);
	FD_ZERO(&m_WriteSet);
	FD_ZERO(&m_ExceptSet);
	m_IsStart = false;
	m_pThread = nullptr;
}

CClient::~CClient()
{
	Close();
}

bool CClient::Create(const char* ip, int port)
{
	WORD WVersionRequest = { 0 };
	WSADATA WSaDate = { 0 };
	sockaddr_in ServAddr = { 0 };

	//注册协议版本
	WVersionRequest = MAKEWORD(2, 2);
	if (0 != WSAStartup(WVersionRequest, &WSaDate))
	{
		perror("WSAStartup");
		return false;
	}
	printf("WSAStartup ok\n");

	//初始化socket
	m_Clientfd = socket(AF_INET, SOCK_STREAM, 0);
	if (m_Clientfd == SOCKET_ERROR)
	{
		perror("socket");
		return false;
	}
	printf("socket ok\n");

	//设置服务器端地址信息
	ServAddr.sin_family = AF_INET;
	inet_pton(AF_INET, ip, &ServAddr.sin_addr);
	ServAddr.sin_port = htons(port);

	//向服务器端发起连接
	if (0 != connect(m_Clientfd, (sockaddr*)&ServAddr, sizeof(ServAddr)))
	{
		perror("connect");
		closesocket(m_Clientfd);
		return false;
	}
	printf("connect ok\n");
	FD_SET(m_Clientfd, &m_ReadSet);
	m_IsStart = true;
	m_pThread = new std::thread(&CClient::GetSendBufHandle, this);
	return true;
}

void CClient::Select()
{
	TIMEVAL TimeVal;//设置超时等待时间
	TimeVal.tv_sec = 5;
	TimeVal.tv_usec = 0;
	char TempBuf[1024] = "";
	std::unique_lock<std::mutex> UniLock(m_Mutex);

	while (true)
	{
		UniLock.unlock();
		FD_SET(m_Clientfd, &m_ReadSet);
		UniLock.lock();
		switch (select(FD_SETSIZE, &m_ReadSet, &m_WriteSet, &m_ExceptSet, &TimeVal))
		{
		case 0:
			printf("超时\n");
			continue;
		case SOCKET_ERROR:
			perror("select");
			continue;
		default:
			if (FD_ISSET(m_Clientfd, &m_ReadSet))
			{
				switch (recv(m_Clientfd, TempBuf, sizeof(TempBuf), 0))
				{
				case 0:
					FD_CLR(m_Clientfd, &m_ReadSet);
					return;
				case SOCKET_ERROR:
					perror("recv");
					break;
				default:
					std::cout << "server:" << TempBuf << std::endl;
					break;
				}
			}

			if (FD_ISSET(m_Clientfd, &m_WriteSet))
			{
				if (0 >= send(m_Clientfd, m_SendBuf.c_str(), 1024, 0))
				{
					perror("send");
				}
				else
				{
					printf("发送：%s\n", m_SendBuf.c_str());
					FD_CLR(m_Clientfd, &m_WriteSet);
				}
			}

			if (FD_ISSET(m_Clientfd, &m_ExceptSet))
			{

			}
			break;
		}
	}
}

void CClient::Close()
{
	closesocket(m_Clientfd);
	WSACleanup();
	m_IsStart = false;
	std::cout << "按回车" << std::endl;
	m_pThread->join();
	delete m_pThread;
}

void CClient::GetSendBufHandle()
{
	char TempBuf[1024] = { 0 };
	std::unique_lock<std::mutex> UniLock(m_Mutex);
	UniLock.unlock();
	while (m_IsStart)
	{
		std::cin >> TempBuf;
		UniLock.lock();
		m_SendBuf = TempBuf;
		FD_SET(m_Clientfd, &m_WriteSet);
		UniLock.unlock();
	}
}

int main()
{
	CClient Client;
	if (Client.Create(IPADDRESS, PORT))
	{
		Client.Select();
		Client.Close();
	}
	system("pause");
	return 0;
}