C++：TCP/IP 网络编程 visual stdio 2010

素颜马尾好姑娘i 2022-11-12 01:47 208阅读 0赞

> ** TCPServer.cpp**

#include <stdio.h>
    #include<winsock.h>
    #pragma comment(lib,"ws2_32.lib")
    #define IP_PROT 6000   //服务端端口号
    #define LISTEN_COUNT_MAX 20    //服务端监听sock最大总数
    #define RECV_MAX_LENGTH 1024   //一次接收最大数据的长度
    SOCKET sockClient=INVALID_SOCKET;
    SOCKADDR_IN addrServer;
    SOCKADDR_IN addrClient;
    int Tongxun_sockets[LISTEN_COUNT_MAX]; //保存客户端sock
    int Tongxun_sockets_max = 0;    //当前保存客户端sock数量
    
    int main(void)
    {
    	WSADATA wsd;
    	WSAStartup(MAKEWORD(2,2),&wsd);
    	sockClient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    	addrServer.sin_family=AF_INET;//sin_family表示地址类型，对于基于TCP/IP传输协议的通信，该值只能是AF_INET；
    	addrServer.sin_port=htons(IP_PROT);//sin_prot表示端口号，例如：21 或者 80 或者 27015，总之在0 ~ 65535之间； htons是端口函数
    	printf("启动服务端TCP模式...\n");
    	bind(sockClient,(LPSOCKADDR)&addrServer,sizeof(addrServer));//类型强制转换,LPSOCKADDR为结构指针 
    	if(listen(sockClient, LISTEN_COUNT_MAX) == SOCKET_ERROR){
    		printf("服务端监听失败...\n");
    		closesocket(sockClient);
    		WSACleanup();
    		return -1;
    	}
    	//监听客户端连接的消息
    	int size=sizeof(addrClient);
    	int sockTongxun= accept(sockClient,(sockaddr FAR*)&addrClient,&size);
    	if(INVALID_SOCKET == sockTongxun){
    			closesocket(sockTongxun);
    			WSACleanup();
    			return -1;
    	}
    	
    	while(1){
    		int ret;
    		struct timeval tv = {0, 500};
    		fd_set fdread;//fd_set数据类型代表着一系列套接字的集合
    		char recvBuf[RECV_MAX_LENGTH];
    		//FD_ZERO(&fdread);//将fdread初始化空集
    		//FD_SET(sockTongxun,&fdread); //将要检查的套接口加入到集合中
    		//ret = select(0, &fdread, NULL, NULL, &tv);//每隔一段时间，检查可读性的套接口
    		//if(ret == 0){continue;}//如果时间限制过期，则为0;如果发生错误，则为SOCKET_ERROR。
    		ret= recv(sockTongxun, recvBuf, RECV_MAX_LENGTH, 0);
    		if(INVALID_SOCKET == sockTongxun || ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() ==WSAECONNRESET)){
    			printf("Clientsocket %d closed.\n", sockTongxun);
    			closesocket(sockTongxun);
    		}
    		else{
    			recvBuf[ret]= '\0';
    			printf("recv data:%s\n",recvBuf);
    			send(sockTongxun,recvBuf, strlen(recvBuf), 0);
    		}
    	}
    	
    	//closesocket(sockTongxun);
    	closesocket(sockClient);
    	WSACleanup();  //释放套接字资源
    	return 1;
    }

> **TCPClient.cpp**

#include <stdio.h>
    #include "WinSock2.h"
    #pragma comment(lib,"ws2_32.lib")
    #define IP_STR_ADDR   "127.0.0.1"
    #define IP_PROT 6000   //服务端端口号
    #define RECV_MAX_LENGTH  1024   //一次接收最大数据的长度
    
    SOCKET sockClient;
    SOCKADDR_IN addrClient;
    const int BufLen=1024;
    char SendBuf[BufLen];
    
    int main(int argc,char* argv[])
    {
    	WSADATA wsd;
    	WSAStartup(MAKEWORD(2,2),&wsd);
    	printf("客户端已经启动...\n");
    	sockClient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    	addrClient.sin_family=AF_INET;
    	addrClient.sin_port=htons(IP_PROT);
    	addrClient.sin_addr.s_addr=inet_addr(IP_STR_ADDR);
    	connect(sockClient,(LPSOCKADDR)&addrClient,sizeof(addrClient));
    	
    	while(1){
    		ZeroMemory(SendBuf,BufLen);
    		fgets(SendBuf,BufLen,stdin);
    		send(sockClient,SendBuf,BufLen,0);
    	}
    	char recvBuf[RECV_MAX_LENGTH];
    	int ret= recv(sockClient, recvBuf, RECV_MAX_LENGTH, 0);
    	if(ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() ==WSAECONNRESET)){}
    	else{
    		recvBuf[ret]= '\0';
    		printf("recv data:%s\n",recvBuf);
    	}
    	closesocket(sockClient);
    	WSACleanup();   //释放套接字资源;
    	return 1;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70][]

> ## **多线程** ##

> **TCPServer.cpp**

#include <stdio.h>
    #include<winsock.h>
    #pragma comment(lib,"ws2_32.lib")
    #define IP_PROT 6000   //服务端端口号
    #define LISTEN_COUNT_MAX 20    //服务端监听sock最大总数
    #define RECV_MAX_LENGTH 1024   //一次接收最大数据的长度
    SOCKET tcp_service_socket=INVALID_SOCKET;
    SOCKADDR_IN tcpServiceAddr;
    SOCKADDR_IN tcpClientAddr;
    int tcp_client_socket[LISTEN_COUNT_MAX]; //保存客户端sock
    int tcp_client_socket_max = 0;    //当前保存客户端sock数量
    DWORD WINAPI ProcMes(LPVOID lpParameter)
    {
    	int i;
    	fd_set fdread;//fd_set数据类型代表着一系列套接字的集合
    	int ret;
    	struct timeval tv = {0, 500};
    	char recvBuf[RECV_MAX_LENGTH];
    
    	while(TRUE)
    	{
    		FD_ZERO(&fdread);//将fdread初始化空集
    		for(i = 0; i < tcp_client_socket_max; i++){
    			FD_SET(tcp_client_socket[i],&fdread); //将要检查的套接口加入到集合中
    		}
    		ret = select(0, &fdread, NULL, NULL, &tv);//每隔一段时间，检查可读性的套接口
    		if(ret == 0){continue;}//如果时间限制过期，则为0;如果发生错误，则为SOCKET_ERROR。
    		for(i = 0; i < tcp_client_socket_max; i++){
    			if(FD_ISSET(tcp_client_socket[i], &fdread)){//检查tcp_client_socket[i]是否在这个fdread集合里面 
    				ret= recv(tcp_client_socket[i], recvBuf, RECV_MAX_LENGTH, 0);
    				if(ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() ==WSAECONNRESET)){
    					printf("Clientsocket %d closed.\n", tcp_client_socket[i]);
    					closesocket(tcp_client_socket[i]);
    					if(i < tcp_client_socket_max){          
    						tcp_client_socket[i--]= tcp_client_socket[--tcp_client_socket_max];
    					}
    				}
    				else{
    						recvBuf[ret]= '\0';
    						printf("recv data:%s\n",recvBuf);
    						send(tcp_client_socket[i],recvBuf, strlen(recvBuf), 0);
    				}
    			}
    		}
    	}
    	return 0;
    }
    int main(void)
    {
    	WSADATA wsd;
    	WSAStartup(MAKEWORD(2,2),&wsd);
    	tcp_service_socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    	tcpServiceAddr.sin_family=AF_INET;//sin_family表示地址类型，对于基于TCP/IP传输协议的通信，该值只能是AF_INET；
    	tcpServiceAddr.sin_port=htons(IP_PROT);//sin_prot表示端口号，例如：21 或者 80 或者 27015，总之在0 ~ 65535之间； htons是端口函数
    	printf("启动服务端TCP模式...\n");
    	bind(tcp_service_socket,(LPSOCKADDR)&tcpServiceAddr,sizeof(tcpServiceAddr));//类型强制转换,LPSOCKADDR为结构指针 
    	if(listen(tcp_service_socket, LISTEN_COUNT_MAX) == SOCKET_ERROR){
    		printf("服务端监听失败...\n");
    		closesocket(tcp_service_socket);
    		WSACleanup();
    		return -1;
    	}
    	HANDLE sock_handle = CreateThread(NULL, 0, ProcMes, NULL, 0, NULL);
    	if(NULL == sock_handle){
    		printf("服务端启动处理线程失败\n");
    		closesocket(tcp_service_socket);
    		WSACleanup();
    		return -1;
    	}
    	//监听客户端连接的消息
    	while (1)
    	{
    		int size=sizeof(tcpClientAddr);
    		int client_sock= accept(tcp_service_socket,(sockaddr FAR*)&tcpClientAddr,&size);
    		if(INVALID_SOCKET == client_sock){
    			closesocket(client_sock);
    			WSACleanup();
    			return -1;
    		}
    
    		tcp_client_socket[tcp_client_socket_max++] = client_sock;
    	}
    	CloseHandle(sock_handle);
    	for(int i=0; i<tcp_client_socket_max-1; i++){
    		closesocket(tcp_client_socket[i]);
    	}
    	closesocket(tcp_service_socket);
    	WSACleanup();  //释放套接字资源
    	return 1;
    }

> **TCPClient.cpp**

#include <stdio.h>
    #include "WinSock2.h"
    #pragma comment(lib,"ws2_32.lib")
    #define IP_STR_ADDR   "127.0.0.1"
    #define IP_PROT 6000   //服务端端口号
    #define RECV_MAX_LENGTH  1024   //一次接收最大数据的长度
    
    SOCKET tcp_socket;
    SOCKADDR_IN tcpAddr;
    const int BufLen=1024;
    char SendBuf[BufLen];
    
    DWORD WINAPI ProcMes(LPVOID lpParameter)
    {
    	char recvBuf[RECV_MAX_LENGTH];
    	int ret= recv(tcp_socket, recvBuf, RECV_MAX_LENGTH, 0);
    	if(ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() ==WSAECONNRESET)){}
    	else{
    		recvBuf[ret]= '\0';
    		printf("recv data:%s\n",recvBuf);
    		//send(tcp_client_socket[i],recvBuf, strlen(recvBuf), 0);
    	}
    	return 0;
    }
    int main(int argc,char* argv[])
    {
    	WSADATA wsd;
    	WSAStartup(MAKEWORD(2,2),&wsd);
    	printf("客户端已经启动...\n");
    	tcp_socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    	tcpAddr.sin_family=AF_INET;
    	tcpAddr.sin_port=htons(IP_PROT);
    	tcpAddr.sin_addr.s_addr=inet_addr(IP_STR_ADDR);
    	connect(tcp_socket,(LPSOCKADDR)&tcpAddr,sizeof(tcpAddr));
    	HANDLE sock_handle = CreateThread(NULL, 0, ProcMes, NULL, 0, NULL);
    	if(NULL == sock_handle){
    		printf("客户端启动处理线程失败\n");
    		closesocket(tcp_socket);
    		WSACleanup();
    		return -1;
    	}
    	while (1)
    	{
    		ZeroMemory(SendBuf,BufLen);
    		fgets(SendBuf,BufLen,stdin);
    		send(tcp_socket,SendBuf,BufLen,0);
    	}
    	closesocket(tcp_socket);
    	WSACleanup();   //释放套接字资源;
    	return 1;
    }

> ### 我是热爱学习的呵呵哒~如果你觉得文章很棒，对你有帮助的话，可以点赞+收藏+加关注喔~ ###
> 
> **如果文章有不正确的地方，欢迎交流指正，我将虚心请教~o(>ω<)o**
> 
> **我会定期更新文章，继续为您提供优质文章**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70]: /images/20221022/484ce646d86a4452acb1ccce6c771af4.png