socket多人聊天程序C语言版(一)

分类：C&C++作者：编程之家用户

首先，不要一步登天直接解决多人聊天这个问题，先把问题化简。
1.多人聊天的核心问题是服务器如何标识不同的客户端，如何根据客户端的需求转发消息给指定客户端。
2.多人聊天转化为C-C聊天，但是不再是直接C-C，而是通过server转发消息，所以变成==>C-S-C。
3.server如何允许2个client同时连接，设置listen函数的第二个参数，最大连接数。
4.server如何标识两个client，用一个结构体数组来存放两个client的信息。
5.server如何转发消息给client，很简单，先接收到的发送给还没接收到的。如图：


6.server如何管理两个client的连接状态，连接成功很简单，就是accpet成功后就是连接成功了。但是怎么判断连接断开呢？这个涉及到的select函数的使用，有点复杂~，所以我就简单的用了一个send函数发送一个空消息来判断是否断开连接，这个不严谨，容易出BUG，但是实践起来简单就使用了它。
7.要用线程来管理接收消息、发送消息、接受请求、管理连接状态。

技术要点：C语言线程函数的使用。 

_beginthreadex函数原型

_ACRTIMP uintptr_t __cdecl _beginthreadex
( _In_opt_ void* _Security,//安全属性，NULL为默认安全属性
 _In_ unsigned _StackSize,//线程堆栈的大小。如果为0，则线程堆栈大小和创建它的线程的相同。一般用0 
 _In_ _beginthreadex_proc_type _StartAddress,//线程函数的地址
 _In_opt_ void* _ArgList,//传进线程的函数
 _In_ unsigned _InitFlag,//线程初始状态，0:立即运行；CREATE_SUSPEND：悬挂（如果出事状态定义为悬挂，就要调用ResumeThread(HANDLE) 来激活线程的运行） 
 _Out_opt_ unsigned* _ThrdAddr //用于记录线程ID的地址
 )

例子:

#include <process.h>
#include <stdio.h>

unsigned __stdcall Thread(void* param)
{
  printf("%d\n",*(int*)param); //这里必须先要强行转换为int*，不然void* 直接解引用会出错。
  return 0;
}

int main()
{
  int i = 0;
  _beginthreadex(NULL,Thread,&i,NULL);
  return 0;
}

1V1,C-S-C聊天例子：
编写环境：win10，VS2015

效果图：

server code：

#include <WinSock2.h>
#include <process.h>
#include <stdio.h>
#include <stdlib.h>
#pragma comment(lib,"ws2_32.lib")

#define SEND_OVER 1             //已经转发消息
#define SEND_YET 0             //还没转发消息

int g_iStatus = SEND_YET;
SOCKET g_ServerSocket = INVALID_SOCKET;   //服务端套接字
SOCKADDR_IN g_ClientAddr = { 0 };      //客户端地址
int g_iClientAddrLen = sizeof(g_ClientAddr);
bool g_bCheckConnect = false;        //检查连接情况
HANDLE g_hRecv1 = NULL;
HANDLE g_hRecv2 = NULL;
//客户端信息结构体
typedef struct _Client
{
  SOCKET sClient;   //客户端套接字
  char buf[128];    //数据缓冲区
  char userName[16];  //客户端用户名
  char IP[20];     //客户端IP
  UINT_PTR flag;    //标记客户端，用来区分不同的客户端
}Client;

Client g_Client[2] = { 0 };         //创建一个客户端结构体

//发送数据线程
unsigned __stdcall ThreadSend(void* param)
{
  int ret = 0;
  int flag = *(int*)param;
  SOCKET client = INVALID_SOCKET;         //创建一个临时套接字来存放要转发的客户端套接字
  char temp[128] = { 0 };             //创建一个临时的数据缓冲区，用来存放接收到的数据
  memcpy(temp,g_Client[!flag].buf,sizeof(temp));
  sprintf(g_Client[flag].buf,"%s: %s",g_Client[!flag].userName,temp);//添加一个用户名头

  if (strlen(temp) != 0 && g_iStatus == SEND_YET) //如果数据不为空且还没转发则转发
    ret = send(g_Client[flag].sClient,g_Client[flag].buf,sizeof(g_Client[flag].buf),0);
  if (ret == SOCKET_ERROR)
    return 1;
  g_iStatus = SEND_OVER;  //转发成功后设置状态为已转发
  return 0;
}

//接受数据
unsigned __stdcall ThreadRecv(void* param)
{
  SOCKET client = INVALID_SOCKET;
  int flag = 0; 
  if (*(int*)param == g_Client[0].flag)      //判断是哪个客户端发来的消息
  {
    client = g_Client[0].sClient;
    flag = 0;
  }  
  else if (*(int*)param == g_Client[1].flag)
  {
    client = g_Client[1].sClient;
    flag = 1;
  }
  char temp[128] = { 0 }; //临时数据缓冲区
  while (1)
  {
    memset(temp,sizeof(temp));
    int ret = recv(client,temp,sizeof(temp),0); //接收数据
    if (ret == SOCKET_ERROR)
      continue;
    g_iStatus = SEND_YET;                //设置转发状态为未转发
    flag = client == g_Client[0].sClient ? 1 : 0;    //这个要设置，否则会出现自己给自己发消息的BUG
    memcpy(g_Client[!flag].buf,sizeof(g_Client[!flag].buf));
    _beginthreadex(NULL,ThreadSend,&flag,NULL); //开启一个转发线程,flag标记着要转发给哪个客户端
    //这里也可能是导致CPU使用率上升的原因。
  }

  return 0;
}

//管理连接
unsigned __stdcall ThreadManager(void* param)
{
  while (1)
  {
    if (send(g_Client[0].sClient,"",sizeof(""),0) == SOCKET_ERROR)
    {
      if (g_Client[0].sClient != 0)
      {
        CloseHandle(g_hRecv1); //这里关闭了线程句柄，但是测试结果断开连C/S接后CPU仍然疯涨
        CloseHandle(g_hRecv2);
        printf("Disconnect from IP: %s,UserName: %s\n",g_Client[0].IP,g_Client[0].userName);
        closesocket(g_Client[0].sClient);  //这里简单的判断：若发送消息失败，则认为连接中断(其原因有多种)，关闭该套接字
        g_Client[0] = { 0 };
      }
    }
    if (send(g_Client[1].sClient,0) == SOCKET_ERROR)
    {
      if (g_Client[1].sClient != 0)
      {
        CloseHandle(g_hRecv1);
        CloseHandle(g_hRecv2);
        printf("Disconnect from IP: %s,g_Client[1].IP,g_Client[1].userName);
        closesocket(g_Client[1].sClient);
        g_Client[1] = { 0 };
      }
    }
    Sleep(2000); //2s检查一次
  }

  return 0;
}

//接受请求
unsigned __stdcall ThreadAccept(void* param)
{

  int i = 0;
  int temp1 = 0,temp2 = 0;
  _beginthreadex(NULL,ThreadManager,NULL,NULL);
  while (1)
  {
    while (i < 2)
    {
      if (g_Client[i].flag != 0)
      {
        ++i;
        continue;
      }
      //如果有客户端申请连接就接受连接
      if ((g_Client[i].sClient = accept(g_ServerSocket,(SOCKADDR*)&g_ClientAddr,&g_iClientAddrLen)) == INVALID_SOCKET)
      {
        printf("accept failed with error code: %d\n",WSAGetLastError());
        closesocket(g_ServerSocket);
        WSACleanup();
        return -1;
      }
      recv(g_Client[i].sClient,g_Client[i].userName,sizeof(g_Client[i].userName),0); //接收用户名
      printf("Successfuuly got a connection from IP:%s,Port: %d,UerName: %s\n",inet_ntoa(g_ClientAddr.sin_addr),htons(g_ClientAddr.sin_port),g_Client[i].userName);
      memcpy(g_Client[i].IP,sizeof(g_Client[i].IP)); //记录客户端IP
      g_Client[i].flag = g_Client[i].sClient; //不同的socke有不同UINT_PTR类型的数字来标识
      i++;
    }
    i = 0;

    if (g_Client[0].flag != 0 && g_Client[1].flag != 0)         //当两个用户都连接上服务器后才进行消息转发
    {
      if (g_Client[0].flag != temp1)   //每次断开一个连接后再次连上会新开一个线程，导致cpu使用率上升,所以要关掉旧的
      {
        if (g_hRecv1)         //这里关闭了线程句柄，但是测试结果断开连C/S接后CPU仍然疯涨
          CloseHandle(g_hRecv1);
        g_hRecv1 = (HANDLE)_beginthreadex(NULL,ThreadRecv,&g_Client[0].flag,NULL); //开启2个接收消息的线程
      }  
      if (g_Client[1].flag != temp2)
      {
        if (g_hRecv2)
          CloseHandle(g_hRecv2);
        g_hRecv2 = (HANDLE)_beginthreadex(NULL,&g_Client[1].flag,NULL);
      }    
    }

    temp1 = g_Client[0].flag; //防止ThreadRecv线程多次开启
    temp2 = g_Client[1].flag;

    Sleep(3000);
  }

  return 0;
}

//启动服务器
int StartServer()
{
  //存放套接字信息的结构
  WSADATA wsaData = { 0 };
  SOCKADDR_IN ServerAddr = { 0 };       //服务端地址
  USHORT uPort = 18000;            //服务器监听端口

  //初始化套接字
  if (WSAStartup(MAKEWORD(2,2),&wsaData))
  {
    printf("WSAStartup failed with error code: %d\n",WSAGetLastError());
    return -1;
  }
  //判断版本
  if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
  {
    printf("wVersion was not 2.2\n");
    return -1;
  }
  //创建套接字
  g_ServerSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  if (g_ServerSocket == INVALID_SOCKET)
  {
    printf("socket failed with error code: %d\n",WSAGetLastError());
    return -1;
  }

  //设置服务器地址
  ServerAddr.sin_family = AF_INET;//连接方式
  ServerAddr.sin_port = htons(uPort);//服务器监听端口
  ServerAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//任何客户端都能连接这个服务器

  //绑定服务器
  if (SOCKET_ERROR == bind(g_ServerSocket,(SOCKADDR*)&ServerAddr,sizeof(ServerAddr)))
  {
    printf("bind failed with error code: %d\n",WSAGetLastError());
    closesocket(g_ServerSocket);
    return -1;
  }
  //设置监听客户端连接数
  if (SOCKET_ERROR == listen(g_ServerSocket,20000))
  {
    printf("listen failed with error code: %d\n",WSAGetLastError());
    closesocket(g_ServerSocket);
    WSACleanup();
    return -1;
  }

  _beginthreadex(NULL,ThreadAccept,0);
  for (int k = 0;k < 100;k++) //让主线程休眠，不让它关闭TCP连接.
    Sleep(10000000);

  //关闭套接字
  for (int j = 0;j < 2;j++)
  {
    if (g_Client[j].sClient != INVALID_SOCKET)
      closesocket(g_Client[j].sClient);
  }
  closesocket(g_ServerSocket);
  WSACleanup();
  return 0;
}

int main()
{
  StartServer(); //启动服务器

  return 0;
}

client code:

#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <WinSock2.h>
#include <process.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#pragma comment(lib,"ws2_32.lib")
#define RECV_OVER 1
#define RECV_YET 0
char userName[16] = { 0 };
int iStatus = RECV_YET;
//接受数据
unsigned __stdcall ThreadRecv(void* param)
{
  char buf[128] = { 0 };
  while (1)
  {
    int ret = recv(*(SOCKET*)param,buf,sizeof(buf),0);
    if (ret == SOCKET_ERROR)
    {
      Sleep(500);
      continue;
    }
    if (strlen(buf) != 0)
    {
      printf("%s\n",buf);
      iStatus = RECV_OVER;
    }
    else
      Sleep(100);  


  }
  return 0;
}

//发送数据
unsigned __stdcall ThreadSend(void* param)
{
  char buf[128] = { 0 };
  int ret = 0;
  while (1)
  {
    int c = getch();
    if(c == 72 || c == 0 || c == 68)//为了显示美观，加一个无回显的读取字符函数
      continue;          //getch返回值我是经过实验得出如果是返回这几个值，则getch就会自动跳过，具体我也不懂。
    printf("%s: ",userName);
    gets_s(buf);
    ret = send(*(SOCKET*)param,0);
    if (ret == SOCKET_ERROR)
      return 1;
  }
  return 0;
}

//连接服务器
int ConnectServer()
{
  WSADATA wsaData = { 0 };//存放套接字信息
  SOCKET ClientSocket = INVALID_SOCKET;//客户端套接字
  SOCKADDR_IN ServerAddr = { 0 };//服务端地址
  USHORT uPort = 18000;//服务端端口
             //初始化套接字
  if (WSAStartup(MAKEWORD(2,WSAGetLastError());
    return -1;
  }
  //判断套接字版本
  if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
  {
    printf("wVersion was not 2.2\n");
    return -1;
  }
  //创建套接字
  ClientSocket = socket(AF_INET,IPPROTO_TCP);
  if (ClientSocket == INVALID_SOCKET)
  {
    printf("socket failed with error code: %d\n",WSAGetLastError());
    return -1;
  }
  //输入服务器IP
  printf("Please input server IP:");
  char IP[32] = { 0 };
  gets_s(IP);
  //设置服务器地址
  ServerAddr.sin_family = AF_INET;
  ServerAddr.sin_port = htons(uPort);//服务器端口
  ServerAddr.sin_addr.S_un.S_addr = inet_addr(IP);//服务器地址

  printf("connecting......\n");
  //连接服务器
  if (SOCKET_ERROR == connect(ClientSocket,sizeof(ServerAddr)))
  {
    printf("connect failed with error code: %d\n",WSAGetLastError());
    closesocket(ClientSocket);
    WSACleanup();
    return -1;
  }
  printf("Connecting server successfully IP:%s Port:%d\n",IP,htons(ServerAddr.sin_port));
  printf("Please input your UserName: ");
  gets_s(userName);
  send(ClientSocket,userName,sizeof(userName),0);
  printf("\n\n");
  _beginthreadex(NULL,&ClientSocket,NULL); //启动接收和发送消息线程
  _beginthreadex(NULL,NULL);
  for (int k = 0;k < 1000;k++)
    Sleep(10000000);
  closesocket(ClientSocket);
  WSACleanup();
  return 0;
}

int main()
{
  ConnectServer(); //连接服务器
  return 0;
}

这程序还有一些BUG，其中最大的就是关掉一个连接后CPU使用率疯涨，我测试过我想到的可能，还是找不到结果~，希望有大神懂的告知一下。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程小技巧。

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

浅谈C/C++中的static和extern关键字
一.C语言中的static关键字 在C语言中，static可以用来修饰局部变量，全局变量以及函数。在不同的情况下static的作用不尽相同。 (1)修饰局部变量 一般情况下，对于局部变量是存放在栈区的，并且局部变量的生命周期在该语句块执行结束时便结束了。但是如果用static进行修饰的话，该变量便存
浅谈C/C++中的指针和数组（二）
浅谈C/C++中的指针和数组（二） 前面已经讨论了指针和数组的一些区别，然而在某些情况下，指针和数组是等同的，下面讨论一下什么时候指针和数组是相同的。C语言标准对此作了说明：规则1：表达式中的数组名被编译器当做一个指向该数组第一个元素的指针； 注：下面几种情况例外 1)数组名作为sizeof的操作数
浅谈C/C++中的指针和数组（一）
浅谈C/C++中的指针和数组（一）指针是C/C++的精华，而指针和数组又是一对欢喜冤家，很多时候我们并不能很好的区分指针和数组，对于刚毕业的计算机系的本科生很少有人能够熟练掌握指针以及数组的用法和区别。造成这种原因可能跟现在大学教学以及现在市面上流行的很多C或者C++教程有关，这些教程虽然通俗易懂，
从两个例子分析C语言的声明
从两个例子分析C语言的声明 在读《C专家编程》一书的第三章时，书中谈到C语言的声明问题，《C专家编程》这本书只有两百多页，却花了一章的内容去阐述这个问题，足以看出这个问题的重要性，要想透彻理解C语言的声明问题仅仅看书是远远不够的，需要平时多实践并大量阅读别人写的代码。下面借鉴《C专家编程》书中的两个
C语言文件操作解析(一)
C语言文件操作解析(一)在讨论C语言文件操作之前，先了解一下与文件相关的东西。一.文本文件和二进制文件 文本文件的定义：由若干行字符构成的计算机文件，存在于计算机系统中。文本文件只能存储文件中的有效字符信息，不能存储图像、声音等信息。狭义上的二进制文件则指除开文本文件之外的文件，如图片、DOC文档。
C语言文件操作解析(三)
C语言文件操作解析(三) 在前面已经讨论了文件打开操作，下面说一下文件的读写操作。文件的读写操作主要有4种，字符读写、字符串读写、块读写以及格式化读写。一.字符读写 字符读写主要使用两个函数fputc和fgetc，两个函数的原型是: int fputc(int ch,FILE *fp);若写入成功则
浅谈C语言中的位段
浅谈C语言中的位段 位段(bit-field)是以位为单位来定义结构体(或联合体)中的成员变量所占的空间。含有位段的结构体(联合体)称为位段结构。采用位段结构既能够节省空间，又方便于操作。 位段的定义格式为: type [var]:digits 其中type只能为int，unsigned int，s
C语言文件操作解析(五)之EOF解析
C语言文件操作解析(五)之EOF解析 在C语言中，有个符号大家都应该很熟悉，那就是EOF(End of File)，即文件结束符。但是很多时候对这个理解并不是很清楚，导致在写代码的时候经常出错，特别是在判断文件是否到达文件末尾时，常常出错。1.EOF是什么? 在VC中查看EOF的定义可知: #def
关于VC++6.0中getline函数的一个bug
关于VC+ʶ.0中getline函数的一个bug 最近在调试程序时，发现getline函数在VC+ʶ.0和其他编译器上运行结果不一样，比如有如下这段程序：#include &lt;iostream&gt;#include &lt;string&gt;using namespace std;int
浅谈C/C++的浮点数在内存中的存储方式
C/C++浮点数在内存中的存储方式 任何数据在内存中都是以二进制的形式存储的，例如一个short型数据1156，其二进制表示形式为00000100 10000100。则在Intel CPU架构的系统中，存放方式为 10000100(低地址单元) 00000100(高地址单元)，因为Intel CPU
浅析C/C++中的switch/case陷阱
浅析C/C++中的switch/case陷阱 先看下面一段代码： 文件main.cpp#includeusing namespace std;int main(int argc, char *argv[]){ int a =0; switch(a) { case ...
浅谈C/C++中的typedef和#define
浅谈C/C++中的typedef和#define 在C/C++中，我们平时写程序可能经常会用到typedef关键字和#define宏定义命令，在某些情况下使用它们会达到相同的效果，但是它们是有实质性的区别，一个是C/C++的关键字，一个是C/C++的宏定义命令，typedef用来为一个已有的数据类型
关于数组指针的一道面试题
看下面一道面试题：#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;int main(void) { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&amp;aʱ); printf(&quot;%d,%d&quot;,*(
浅谈C语言中的联合体
联合体union 当多个数据需要共享内存或者多个数据每次只取其一时，可以利用联合体(union)。在C Programming Language 一书中对于联合体是这么描述的： 1)联合体是一个结构； 2)它的所有成员相对于基地址的偏移量都为0； 3)此结构空间要大到足够容纳最&quot;宽&quo
从一个程序的Bug解析C语言的类型转换
从一个程序的Bug解析C语言的类型转换 先看下面一段程序，这段程序摘自《C 专家编程》：#include&lt;stdio.h&gt;int array[]={23,34,12,17,204,99,16};#define TOTAL_ELEMENTS (sizeof(array)/sizeof(ar
大端和小端
大端和小端 嵌入式开发者应该对大端和小端很熟悉。在内存单元中数据是以字节为存储单位的，对于多字节数据，在小端模式中，低字节数据存放在低地址单元，而在大端模式中，低字节数据存放在高地址单元。比如一个定义一个short型的变量a，赋值为1，由于short型数据占2字节。在小端模式中，其存放方式为0X40
位运算和sizeof运算符
位运算和sizeof运算符 C语言中提供了一些运算符可以直接操作整数的位，称为位运算，因此位运算中的操作数都必须是整型的。位运算的效率是比较高的，而且位运算运用好的话会达到意想不到的效果。位运算主要有6种：与(&amp;)，或(|)，取反(~)，异或(^)，左移(&gt;)。1.位运算中的类型转换位
C语言文件操作解析(四)
C语言文件操作解析(四)在文件操作中除了打开操作以及读写操作，还有几种比较常见的操作。下面介绍一下这些操作中涉及到的函数。一.移动位置指针的函数 rewind函数和fseek函数，这两个函数的原型是:void rewind(FILE *fp); 将位置指针移动到文件首 int fseek(FILE
结构体字节对齐
结构体字节对齐 在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排
C语言文件操作解析(二)
C语言文件操作解析(二)C语言中对文件进行操作必须首先打开文件，打开文件主要涉及到fopen函数。fopen函数的原型为 FILE* fopen(const char *path,const char *mode) 其中path为文件路径，mode为打开方式 1)对于文件路径，只需注意若未明确给出绝
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot