上次实现了一个socket编程的C/S模型的通信程序，这次实现一个基于控制台的聊天程序。同样是socket技术的应用，同样是基于TCP协议的通信方式。这次的实现中遇到好多问题。废话不多说，直接进入主题。

聊天室程序，我是这么想的，需要一个服务端来控制登录用户的信息，然后可以登录很多不同的客户端。所以其实这个聊天程序事实上也是两个程序，一个服务端的程序，一个客户端的程序，服务端开一个，客户端可以开任意多个。从客户端连接到服务端，然后进行通信就可以了。

首先来设计客户端：

我认为客户端需要具备这几种功能：1、能够使用自定义的名字登录进聊天室；2、能够向登录的所有用户发送自己的消息；3、能够接受所有用户的消息；4、能够要求服务端返回当前在线用户列表；5、能够退出聊天室。

这样我的客户端程序就非常明晰了。首先需要一个登录函数login()，然后一个发送消息函数sendMessage()，继续是一个接受所有用户消息的函数RecvThread()，这里起这个名字，内行一眼就看出来是一个线程回调函数，没错，我把接受其他用户的信息设计了一个独立的线程进行处理，后话以后讲；接着是一个显示所有在线用户的函数viewList()，最后是一个退出聊天室的函数exitChatRoom()。

再来设计服务端：

服务端应该具备这些功能：1、接受用户登录并记录；2、显示所有在线用户；3、向所有用户发送系统消息；4、接受到任何一个用户的信息，把它转发到所有的客户端去；5、用户退出聊天室的处理；6、处理来自客户端显示所有在线用户的消息。

我们服务端的程序也差不多成型了。首先我们需要维护一个列表，这个列表需要记录所有在线用户，对表的操作包括用户登录时添加用户，用户退出时删除用户，addToOnlineQueue()函数用于向列表添加用户，logoutRoom()函数用户处理用户退出聊天室；showOnlineQueue()函数用于显示所有在线用户；recvMessage()函数用于接收所有用户的信息并转发；sendMsg()用于向所有客户端发送系统消息；sendListMsg()函数用于向所有有请求的客户端发送在线用户列表。

为了实现我设想的这一切，我还需要设计一些辅助的结构体来帮助我完成：

比如在客户端和服务端之间传递的报文需要自己设计，我设计的报文如下：



    

  1. typedef struct tagGRAMHEAD_t   
    2. 

  2. {   
    3. 

  3. 
    char    COMMAND;     //数据包命令   

    4. 

  4. 
    short    PACKID;      //包ID   

    5. 

  5. 
    char    COUNT;       //包总数   

    6. 

  6. 
    char    NO;           //包分块序号   

    7. 

  7. 
    short    LENGTH;      //包长度   

    8. 

  8. 
    char    USERNO[20];   //用户名   

    9. 

  9.     tagGRAMHEAD_t()   
    10. 

  10.     {   
    11. 

  11.         COMMAND =    0;   
    12. 

  12.         PACKID    =    0;   
    13. 

  13.         COUNT    =    0;   
    14. 

  14.         NO        =    0;   
    15. 

  15.         LENGTH  =    0;   
    16. 

  16. 
        memset(USERNO, 0, sizeof(USERNO));   

    17. 

  17.     }   
    18. 

  18. }GramHead, *pGramHead;  
    19. 



在服务端还需要维护一个在线用户列表：




    

  1. typedef struct tagUserOnline   
    2. 

  2. {   
    3. 

  3. 
    char userName[20];                //用户名   

    4. 

  4. 
    sockaddr_in clientAddr;            //SOCKET地址   

    5. 

  5.     tagUserOnline()   
    6. 

  6.     {   
    7. 

  7.         memset(userName, 0, 20);   
    8. 

  8. 
        memset(&clientAddr, 0, sizeof(clientAddr));   

    9. 

  9.     }   
    10. 

  10. }UserOnline;  
    11. 



然后为了区分不用的报文，以及报文的目的，我需要设计一个报文标志，定义如下：




    

  1. #define C_LOGIN          50             //客户登陆   
    2. 

  2. 
#define C_LOGOUT         51             //客户离开   

    3. 

  3. 
#define C_MESSAGE        52             //客户聊天信息   

    4. 

  4. 
#define C_RECVMESSAGE    53             //客户接收到客户的聊天消息   

    5. 

  5. 
#define C_USERLIST       54             //客户查看用户列表命令   

    6. 

  6. 
#define S_LOGIN          70             //服务器返回登陆成功   

    7. 

  7. 
#define S_LOGOUT         71             //服务器返回离开成功   

    8. 

  8. 
#define S_MESSAGE        72             //系统消息   

    9. 

  9. 
#define S_USERLIST       73             //服务器返回用户列表命令   

    10. 

  10. 
#define S_USERLOGIN      74             //用户登陆，通知其他用户  

    11. 



当然后来的设计中我把服务端的命令控制处理也独立用一个线程函数来处理了。程序员最喜欢看的就是代码了，我就不多废话了，直接看代码吧：




    

  1. chatSrv.h  
    2. 

  2.  
    3. 

  3. 
#ifndef _CHATSTRUCT_H   

    4. 

  4. 
#define _CHATSTRUCT_H   

    5. 

  5.    
    6. 

  6. 
//在线用户的队列   

    7. 

  7. 
#pragma pack(1)   

    8. 

  8. 
typedef struct tagUserOnline   

    9. 

  9. {   
    10. 

  10. 
    char userName[20];              //用户名   

    11. 

  11. 
    sockaddr_in clientAddr;         //SOCKET地址   

    12. 

  12.     tagUserOnline()   
    13. 

  13.     {   
    14. 

  14.         memset(userName, 0, 20);   
    15. 

  15. 
        memset(&clientAddr, 0, sizeof(clientAddr));   

    16. 

  16.     }   
    17. 

  17. }UserOnline;   
    18. 

  18. 
#pragma pack()   

    19. 

  19.    
    20. 

  20.    
    21. 

  21. 
//数据包头   

    22. 

  22. 
#pragma pack(1)   

    23. 

  23. 
typedef struct tagGRAMHEAD_t   

    24. 

  24. {   
    25. 

  25. 
    char    COMMAND;      //数据包命令   

    26. 

  26. 
    short   PACKID;       //包ID   

    27. 

  27. 
    char    COUNT;        //包总数   

    28. 

  28. 
    char    NO;           //包分块序号   

    29. 

  29. 
    short   LENGTH;       //包长度   

    30. 

  30. 
    char    USERNO[20];   //用户名   

    31. 

  31.     tagGRAMHEAD_t()   
    32. 

  32.     {   
    33. 

  33.         COMMAND =   0;   
    34. 

  34.         PACKID  =   0;   
    35. 

  35.         COUNT   =   0;   
    36. 

  36.         NO      =   0;   
    37. 

  37.         LENGTH  =   0;   
    38. 

  38. 
        memset(USERNO, 0, sizeof(USERNO));   

    39. 

  39.     }   
    40. 

  40. }GramHead, *pGramHead;   
    41. 

  41. 
#pragma pack()   

    42. 

  42.    
    43. 

  43. 
#define C_LOGIN          50                  //客户登陆   

    44. 

  44. 
#define C_LOGOUT         51                  //客户离开   

    45. 

  45. 
#define C_MESSAGE        52                  //客户聊天信息   

    46. 

  46. 
#define C_RECVMESSAGE    53                  //客户接收到客户的聊天消息   

    47. 

  47. 
#define C_USERLIST       54                  //客户查看用户列表命令   

    48. 

  48.    
    49. 

  49. 
#define S_LOGIN          70                  //服务器返回登陆成功   

    50. 

  50. 
#define S_LOGOUT         71                  //服务器返回离开成功   

    51. 

  51. 
#define S_MESSAGE        72                  //系统消息   

    52. 

  52. 
#define S_USERLIST       73                  //服务器返回用户列表命令   

    53. 

  53. 
#define S_USERLOGIN      74                  //用户登陆，通知其他用户   

    54. 

  54.  
    55. 

  55. 
#define PORT             7788  

    56. 

  56. 
#define BUFFER_SIZE      1024  

    57. 

  57.  
    58. 

  58.  
    59. 

  59. 
#endif   

    60. 

  60.  
    61. 

  61. 
//服务器命令线程      

    62. 

  62. 
void serverCommandThread();     

    63. 

  63. 
//添加用户到列表      

    64. 

  64. 
void addToOnlineQueue(sockaddr_in from, char *name);     

    65. 

  65. 
//显示所有在线用户      

    66. 

  66. 
void showOnlineQueue();     

    67. 

  67. 
//用户退出聊天室      

    68. 

  68. 
void logoutRoom(sockaddr_in &from);     

    69. 

  69. 
//接收到聊天消息的处理函数      

    70. 

  70. 
void recvMessage(sockaddr_in &from, GramHead* pHead, char *buf);     

    71. 

  71. 
//发送消息      

    72. 

  72. 
void sendMsg(char *data, char command);     

    73. 

  73. 
//找出在线用户列表存放到pList中      

    74. 

  74. 
void viewList(char *pList);     

    75. 

  75. 
//将数据发送到指定地址      

    76. 

  76. 
void sendListMsg(char *data, char command, sockaddr_in &from);   

    77. 





    

  1. chatSrv.cpp  
    2. 

  2.  
    3. 

  3. 
#include <winsock2.h>      

    4. 

  4. 
#include <iostream.h>      

    5. 

  5. 
#include <queue>      

    6. 

  6. 
#include <list>      

    7. 

  7. 
#include "chatSrv.h"      

    8. 

  8.      
    9. 

  9. 
#pragma comment(lib, "wsock32.lib")      

    10. 

  10.      
    11. 

  11. 
HANDLE thread_commandHandle;                 //定义接收线程句柄        

    12. 

  12. 
std::list <UserOnline> userOnlineList;       //在线用户队列      

    13. 

  13. 
SOCKET sock;                                 //socket      

    14. 

  14.      
    15. 

  15. 
void main()     

    16. 

  16. {        
    17. 

  17. 
    //1.启动SOCKET库，版本为2.0      

    18. 

  18. 
    WORD wVersionRequested;     

    19. 

  19.     WSADATA wsaData;     
    20. 

  20. 
    int err;   

    21. 

  21.       
    22. 

  22.     wVersionRequested = MAKEWORD(2, 0);        
    23. 

  23.     err = WSAStartup(wVersionRequested, &wsaData);     
    24. 

  24. 
    if (err != 0)      

    25. 

  25.     {     
    26. 

  26. 
        cout << "Socket2.0初始化失败，Exit!";     

    27. 

  27. 
        return;     

    28. 

  28.     }        
    29. 

  29. 
    if ((LOBYTE(wsaData.wVersion)!= 2) || (HIBYTE(wsaData.wVersion) != 0))      

    30. 

  30.     {     
    31. 

  31.         WSACleanup();     
    32. 

  32. 
        return;      

    33. 

  33.     }     
    34. 

  34.          
    35. 

  35. 
    //2.创建socket，      

    36. 

  36.     sock = socket(AF_INET, SOCK_DGRAM, 0);     
    37. 

  37.          
    38. 

  38. 
    if (sock == INVALID_SOCKET)   

    39. 

  39.     {     
    40. 

  40. 
        cout << "Socket 创建失败，Exit!";     

    41. 

  41. 
        return;     

    42. 

  42.     }     
    43. 

  43.          
    44. 

  44. 
    //3.绑定      

    45. 

  45. 
    sockaddr_in myaddr; //sockaddr_in相当于sockaddr结构      

    46. 

  46. 
    memset(&myaddr, 0, sizeof(myaddr));     

    47. 

  47.     myaddr.sin_family = AF_INET;     
    48. 

  48.     myaddr.sin_addr.s_addr = ADDR_ANY;     
    49. 

  49.     myaddr.sin_port = htons(PORT);         
    50. 

  50. 
    bind(sock, (sockaddr*)&myaddr, sizeof(myaddr));     

    51. 

  51.          
    52. 

  52. 
    cout << "服务器开启成功！" << endl;     

    53. 

  53.  
    54. 

  54. 
    DWORD session_thread_id = 1;     

    55. 

  55.     thread_commandHandle = CreateThread(0, 0,   
    56. 

  56.         (LPTHREAD_START_ROUTINE)serverCommandThread,     
    57. 

  57.         0, 0, &session_thread_id);     
    58. 

  58.      
    59. 

  59. 
    //接收到的SOCK地址      

    60. 

  60.     sockaddr_in from;     
    61. 

  61. 
    memset(&from, 0, sizeof(from));     

    62. 

  62.          
    63. 

  63.     GramHead head, backHead;     
    64. 

  64. 
    int fromlength = sizeof(SOCKADDR), nnlen;    

    65. 

  65.       
    66. 

  66.     nnlen = fromlength;     
    67. 

  67. 
    char *buf = new char[BUFFER_SIZE];     

    68. 

  68.     memset(buf, 0, BUFFER_SIZE);     
    69. 

  69.  
    70. 

  70. 
    long number = 0;     

    71. 

  71. 
    while (1)     

    72. 

  72.     {     
    73. 

  73.         number++;     
    74. 

  74.      
    75. 

  75.         recvfrom(sock, buf, BUFFER_SIZE, 0,   
    76. 

  76. 
                 (struct sockaddr FAR *)&from,   

    77. 

  77. 
                 (int FAR *)&fromlength);     

    78. 

  78.  
    79. 

  79. 
        memcpy(&head, buf, sizeof(GramHead));     

    80. 

  80. 
        switch (head.COMMAND)     

    81. 

  81.         {     
    82. 

  82. 
        case C_LOGIN:                                   //登陆成功      

    83. 

  83.             backHead.COMMAND = S_LOGIN;     
    84. 

  84. 
            memcpy(buf, &backHead, sizeof(GramHead));     

    85. 

  85. 
            if (sendto(sock, buf, sizeof(GramHead), 0, (sockaddr*)&from, nnlen)     

    86. 

  86.                 == SOCKET_ERROR)     
    87. 

  87.             {  
    88. 

  88. 
                cout << "main" << endl;  

    89. 

  89.                 cout << WSAGetLastError() << endl;   
    90. 

  90.             }  
    91. 

  91. 
            cout << "用户" << (unsigned char *)head.USERNO << "登陆到聊天室！" << endl;     

    92. 

  92. 
            addToOnlineQueue(from, head.USERNO);        //添加加用户到在线列表      

    93. 

  93. 
            cout << "聊天室当前人数为：" << userOnlineList.size() << endl;     

    94. 

  94. 
//          showOnlineQueue();                          //显示用户      

    95. 

  95. 
            break;     

    96. 

  96. 
        case C_LOGOUT:                                  //用户退出聊天室      

    97. 

  97.             logoutRoom(from);     
    98. 

  98. 
            break;     

    99. 

  99. 
        case C_MESSAGE:                                 //用户聊天信息      

    100. 

  100. 
            char data[BUFFER_SIZE-sizeof(GramHead)];     

    101. 

  101. 
            memcpy(data, buf + sizeof(GramHead), BUFFER_SIZE - sizeof(GramHead));     

    102. 

  102.             recvMessage(from, &head, data);     
    103. 

  103. 
            break;     

    104. 

  104. 
        case C_USERLIST:     

    105. 

  105. 
            char plist[BUFFER_SIZE - sizeof(GramHead)];     

    106. 

  106. 
            memcpy(plist, buf + sizeof(GramHead), BUFFER_SIZE - sizeof(GramHead));     

    107. 

  107.             viewList(plist);     
    108. 

  108.             sendListMsg(plist, S_USERLIST, from);     
    109. 

  109. 
            break;     

    110. 

  110.         }     
    111. 

  111.         Sleep(500);     
    112. 

  112.         memset(buf, 0, BUFFER_SIZE);     
    113. 

  113.     }     
    114. 

  114. 
    delete buf;      

    115. 

  115.          
    116. 

  116. 
    if (!closesocket(sock))      

    117. 

  117.     {     
    118. 

  118.         WSAGetLastError();     
    119. 

  119. 
        return;     

    120. 

  120.     }     
    121. 

  121. 
    if (!WSACleanup())      

    122. 

  122.     {     
    123. 

  123.         WSAGetLastError();     
    124. 

  124. 
        return;     

    125. 

  125.     }     
    126. 

  126. }     
    127. 

  127.      
    128. 

  128. 
void addToOnlineQueue(sockaddr_in from, char *name)     

    129. 

  129. {     
    130. 

  130.     sendMsg(name, S_USERLOGIN);   
    131. 

  131.       
    132. 

  132.     UserOnline online;     
    133. 

  133.     online.clientAddr = from;     
    134. 

  134.     strcpy(online.userName, name);     
    135. 

  135.     userOnlineList.push_back(online);     
    136. 

  136. }     
    137. 

  137.      
    138. 

  138. 
void showOnlineQueue()     

    139. 

  139. {     
    140. 

  140. 
    int size = userOnlineList.size();     

    141. 

  141. 
    if (size == 0)     

    142. 

  142.     {     
    143. 

  143. 
        cout << "当前没有用户在线...." << endl;     

    144. 

  144. 
        return;     

    145. 

  145.     }     
    146. 

  146. 
    else     

    147. 

  147.     {     
    148. 

  148. 
        cout << "---------------------------------" << endl;     

    149. 

  149. 
        cout << "当前在线人数为：" << size << endl;     

    150. 

  150.     }     
    151. 

  151.  
    152. 

  152.     std::list <UserOnline>::iterator theIterator;     
    153. 

  153. 
    for (theIterator = userOnlineList.begin(); theIterator != userOnlineList.end(); theIterator++)     

    154. 

  154.     {  
    155. 

  155. 
        cout << "IP地址：" << inet_ntoa(theIterator->clientAddr.sin_addr)     

    156. 

  156. 
        << "  端口号：" << theIterator->clientAddr.sin_port << " 用户名："     

    157. 

  157.         << theIterator->userName << endl;     
    158. 

  158.     }  
    159. 

  159. 
    cout << "---------------------------------" << endl;     

    160. 

  160. }     
    161. 

  161.      
    162. 

  162. 
void logoutRoom(sockaddr_in &from)     

    163. 

  163. {     
    164. 

  164. 
    char msg[BUFFER_SIZE-sizeof(GramHead)];     

    165. 

  165.     std::list <UserOnline>::iterator theIterator;     
    166. 

  166. 
    for (theIterator = userOnlineList.begin(); theIterator != userOnlineList.end(); theIterator++)     

    167. 

  167.     {     
    168. 

  168. 
        if (inet_ntoa(theIterator->clientAddr.sin_addr) == inet_ntoa(from.sin_addr) &&   

    169. 

  169.             theIterator->clientAddr.sin_port == from.sin_port)     
    170. 

  170.         {     
    171. 

  171. 
            memcpy(msg, theIterator->userName, sizeof(theIterator->userName));     

    172. 

  172. 
            cout << msg << "离开了聊天室......" << endl;     

    173. 

  173.             userOnlineList.erase(theIterator);     
    174. 

  174.             sendMsg(msg, S_LOGOUT);     
    175. 

  175. 
            break;     

    176. 

  176.         }     
    177. 

  177.     }     
    178. 

  178. 
    cout << "当前在线人数为：" << userOnlineList.size() << endl;     

    179. 

  179. }     
    180. 

  180.      
    181. 

  181.      
    182. 

  182. 
void recvMessage(sockaddr_in &from, GramHead* pHead, char *buf)     

    183. 

  183. {     
    184. 

  184. 
    char dataBuf[BUFFER_SIZE];     

    185. 

  185.     GramHead head;     
    186. 

  186. 
    memcpy(head.USERNO, pHead->USERNO, sizeof(pHead->USERNO));   

    187. 

  187.  
    188. 

  188.     head.COMMAND = C_RECVMESSAGE;     
    189. 

  189. 
    memcpy(dataBuf, &head, sizeof(GramHead));     

    190. 

  190. 
    memcpy(dataBuf + sizeof(GramHead), buf, BUFFER_SIZE - sizeof(GramHead));     

    191. 

  191.  
    192. 

  192.     std::list <UserOnline>::iterator theIterator;     
    193. 

  193. 
    for (theIterator = userOnlineList.begin(); theIterator != userOnlineList.end(); theIterator++)     

    194. 

  194.     {        
    195. 

  195. 
        if (sendto(sock, dataBuf, BUFFER_SIZE, 0, (sockaddr*)&theIterator->clientAddr, sizeof(SOCKADDR))     

    196. 

  196.             == SOCKET_ERROR)     
    197. 

  197.         {  
    198. 

  198. 
            //cout << "recvMessage" << endl;  

    199. 

  199.             cout << WSAGetLastError() << endl;     
    200. 

  200.         }  
    201. 

  201.     }     
    202. 

  202. }     
    203. 

  203.      
    204. 

  204. 
void sendMsg(char *data, char command)     

    205. 

  205. {     
    206. 

  206. 
    char buf[BUFFER_SIZE];     

    207. 

  207.     memset(buf, 0, BUFFER_SIZE);    
    208. 

  208.       
    209. 

  209.     GramHead head;     
    210. 

  210.     head.COMMAND = command;     
    211. 

  211.      
    212. 

  212. 
    memcpy(buf, &head, sizeof(GramHead));     

    213. 

  213. 
    memcpy(buf + sizeof(GramHead), data, BUFFER_SIZE - sizeof(GramHead));     

    214. 

  214.          
    215. 

  215.     std::list <UserOnline>::iterator theIterator;     
    216. 

  216. 
    for (theIterator = userOnlineList.begin(); theIterator != userOnlineList.end(); theIterator++)     

    217. 

  217.     {        
    218. 

  218. 
        if (sendto(sock, buf, BUFFER_SIZE, 0, (sockaddr*)&theIterator->clientAddr, sizeof(SOCKADDR))     

    219. 

  219.             == SOCKET_ERROR)     
    220. 

  220.         {  
    221. 

  221. 
            //cout << "sendMsg" << endl;  

    222. 

  222.             cout << WSAGetLastError() << endl;     
    223. 

  223.         }  
    224. 

  224.     }     
    225. 

  225. }     
    226. 

  226.      
    227. 

  227. 
void sendListMsg(char *data, char command, sockaddr_in &from)     

    228. 

  228. {     
    229. 

  229. 
    char buf[BUFFER_SIZE];     

    230. 

  230.     memset(buf, 0, BUFFER_SIZE);    
    231. 

  231.       
    232. 

  232.     GramHead head;     
    233. 

  233.     head.COMMAND = command;     
    234. 

  234.          
    235. 

  235. 
    memcpy(buf, &head, sizeof(GramHead));     

    236. 

  236. 
    memcpy(buf + sizeof(GramHead), data, BUFFER_SIZE - sizeof(GramHead));     

    237. 

  237. 
    if (sendto(sock, buf, BUFFER_SIZE, 0, (sockaddr*)&from, sizeof(SOCKADDR))     

    238. 

  238.         == SOCKET_ERROR)    
    239. 

  239.     {  
    240. 

  240. 
        //cout << "sendListMsg" << endl;  

    241. 

  241.         cout << WSAGetLastError() << endl;    
    242. 

  242.     }  
    243. 

  243. }     
    244. 

  244.      
    245. 

  245. 
//用户输入命令，完成操作      

    246. 

  246. 
void serverCommandThread()     

    247. 

  247. {     
    248. 

  248. 
    char ch[BUFFER_SIZE-sizeof(GramHead)];     

    249. 

  249. 
    while (1)     

    250. 

  250.     {     
    251. 

  251.         Sleep(1000);     
    252. 

  252. 
        memset(ch, 0, BUFFER_SIZE - sizeof(GramHead));    

    253. 

  253.           
    254. 

  254. 
        //cin >> ch;     

    255. 

  255.         gets(ch);  
    256. 

  256. 
        if (!strcmp(ch, "list"))     

    257. 

  257.         {     
    258. 

  258.             showOnlineQueue();     
    259. 

  259.         }     
    260. 

  260. 
        else if (!strcmp(ch, "help"))     

    261. 

  261.         {     
    262. 

  262. 
            cout << "---------------------------------" << endl;     

    263. 

  263. 
            cout << "[list] 命令查看在线用户列表" << endl;     

    264. 

  264. 
            cout << "[send] 命令发送信息" << endl;     

    265. 

  265. 
            cout << "---------------------------------" << endl;     

    266. 

  266.         }     
    267. 

  267. 
        else if (ch[0] == 's' && ch[1] == 'e' && ch[2] == 'n' && ch[3] == 'd')     

    268. 

  268.         {     
    269. 

  269.             sendMsg(ch + 4, S_MESSAGE);     
    270. 

  270.         }     
    271. 

  271.     }     
    272. 

  272. }     
    273. 

  273.      
    274. 

  274. 
void viewList(char *pList)     

    275. 

  275. {     
    276. 

  276.     memset(pList, 0, BUFFER_SIZE);     
    277. 

  277. 
    int start = 0, length = 0;     

    278. 

  278.  
    279. 

  279.     std::list <UserOnline>::iterator theIterator;     
    280. 

  280. 
    for (theIterator = userOnlineList.begin(); theIterator != userOnlineList.end(); theIterator++)     

    281. 

  281.     {     
    282. 

  282.         length = strlen(theIterator->userName);     
    283. 

  283.         memcpy(pList + start, theIterator->userName, length);     
    284. 

  284. 
        pList[start+length] = '\n';     

    285. 

  285.         start += length + 1;     
    286. 

  286.     }     
    287. 

  287. }   
    288. 





    

  1. chatCli.h  
    2. 

  2.  
    3. 

  3. 
#ifndef _CHATSTRUCT_H   

    4. 

  4. 
#define _CHATSTRUCT_H   

    5. 

  5.    
    6. 

  6. 
//数据包头   

    7. 

  7. 
#pragma pack(1)   

    8. 

  8. 
typedef struct tagGRAMHEAD_t   

    9. 

  9. {   
    10. 

  10. 
    char    COMMAND;      //数据包命令   

    11. 

  11. 
    short   PACKID;       //包ID   

    12. 

  12. 
    char    COUNT;        //包总数   

    13. 

  13. 
    char    NO;           //包分块序号   

    14. 

  14. 
    short   LENGTH;       //包长度   

    15. 

  15. 
    char    USERNO[20];   //用户名   

    16. 

  16.     tagGRAMHEAD_t()   
    17. 

  17.     {   
    18. 

  18.         COMMAND =   0;   
    19. 

  19.         PACKID  =   0;   
    20. 

  20.         COUNT   =   0;   
    21. 

  21.         NO      =   0;   
    22. 

  22.         LENGTH  =   0;   
    23. 

  23. 
        memset(USERNO, 0, sizeof(USERNO));   

    24. 

  24.     }   
    25. 

  25. }GramHead, *pGramHead;   
    26. 

  26. 
#pragma pack()   

    27. 

  27.    
    28. 

  28. 
#define C_LOGIN             50                  //客户登陆   

    29. 

  29. 
#define C_LOGOUT            51                  //客户离开   

    30. 

  30. 
#define C_MESSAGE           52                  //客户发送聊天信息   

    31. 

  31. 
#define C_RECVMESSAGE       53                  //客户接收到客户的聊天消息   

    32. 

  32. 
#define C_USERLIST          54                  //客户查看用户列表命令   

    33. 

  33.    
    34. 

  34. 
#define S_LOGIN             70                  //服务器返回登陆成功   

    35. 

  35. 
#define S_LOGOUT            71                  //服务器返回离开成功   

    36. 

  36. 
#define S_MESSAGE           72                  //系统消息   

    37. 

  37. 
#define S_USERLIST          73                  //服务器返回用户列表命令   

    38. 

  38. 
#define S_USERLOGIN         74                  //用户登陆，通知其他用户   

    39. 

  39.    
    40. 

  40. 
#define Srv_IP_ADDR         "127.0.0.1"  

    41. 

  41. 
#define PORT                7788  

    42. 

  42. 
#define BUFFER_SIZE         1024  

    43. 

  43. 
#define LOGIN_NAME_LENGTH   20  

    44. 

  44.  
    45. 

  45. 
#endif   

    46. 

  46.  
    47. 

  47. 
bool login();                               //登陆      

    48. 

  48. 
void sendMessage(char *buf, int length);    //发送聊天消息      

    49. 

  49. 
void viewList();                            //查看用户列表      

    50. 

  50. 
bool exitChatRoom();                        //退出聊天室    

    51. 





    

  1. chatCli.cpp  
    2. 

  2.  
    3. 

  3. 
#include <winsock2.h>      

    4. 

  4. 
#include <iostream.h>    

    5. 

  5. 
#include <stdio.h>    

    6. 

  6. 
#include "chatCli.h"      

    7. 

  7. 
#pragma comment(lib, "wsock32.lib")      

    8. 

  8.      
    9. 

  9. 
SOCKET sock;          //socket      

    10. 

  10. 
sockaddr_in addrto;   //发往的地址      

    11. 

  11.     
    12. 

  12. 
char loginName[LOGIN_NAME_LENGTH];  //登录用户名  

    13. 

  13. 
char sendMsg[BUFFER_SIZE];          //发送缓冲区      

    14. 

  14.      
    15. 

  15. 
HANDLE thread_recvHandle;   //定义接收线程句柄      

    16. 

  16. 
void RecvThread();          //接收线程      

    17. 

  17.      
    18. 

  18. 
void main()     

    19. 

  19. {        
    20. 

  20. 
    //1.启动SOCKET库，版本为2.0      

    21. 

  21. 
    WORD wVersionRequested;     

    22. 

  22.     WSADATA wsaData;     
    23. 

  23. 
    int err;         

    24. 

  24.  
    25. 

  25.     wVersionRequested = MAKEWORD(2, 0);        
    26. 

  26.     err = WSAStartup(wVersionRequested, &wsaData);     
    27. 

  27. 
    if (err != 0)      

    28. 

  28.     {     
    29. 

  29. 
        cout << "Socket2.0初始化失败，Exit!";     

    30. 

  30. 
        return;  

    31. 

  31.     }        
    32. 

  32. 
    if ((LOBYTE(wsaData.wVersion) != 2) || (HIBYTE(wsaData.wVersion) != 0))    

    33. 

  33.     {     
    34. 

  34.         WSACleanup();     
    35. 

  35. 
        return;      

    36. 

  36.     }     
    37. 

  37.          
    38. 

  38. 
    //2.创建socket，      

    39. 

  39.     sock = socket(AF_INET, SOCK_DGRAM, 0);     
    40. 

  40.          
    41. 

  41. 
    if (sock == INVALID_SOCKET )   

    42. 

  42.     {     
    43. 

  43. 
        cout << "Socket 创建失败，Exit!";     

    44. 

  44. 
        return;     

    45. 

  45.     }     
    46. 

  46.          
    47. 

  47. 
    //3.设置发往的地址      

    48. 

  48. 
    memset(&addrto, 0, sizeof(addrto));     

    49. 

  49.     addrto.sin_family = AF_INET;     
    50. 

  50. 
    addrto.sin_addr.s_addr = inet_addr(Srv_IP_ADDR); //此处应填服务器IP         

    51. 

  51. 
    addrto.sin_port = htons(PORT); //端口号必须和服务器绑定的端口号一致      

    52. 

  52.          
    53. 

  53. 
    int nlen = sizeof(addrto);     

    54. 

  54. 
    unsigned int uIndex = 1;     

    55. 

  55.          
    56. 

  56. 
    while (!login())     

    57. 

  57.     {     
    58. 

  58. 
        continue;     

    59. 

  59.     }     
    60. 

  60.      
    61. 

  61. 
    //创建会话线程  

    62. 

  62. 
    DWORD session_thread_id = 1;     

    63. 

  63.     thread_recvHandle = CreateThread(0, 0,   
    64. 

  64.         (LPTHREAD_START_ROUTINE)RecvThread,     
    65. 

  65.         0, 0, &session_thread_id);     
    66. 

  66.  
    67. 

  67. 
    while (true)     

    68. 

  68.     {     
    69. 

  69.         memset(sendMsg, 0, BUFFER_SIZE);     
    70. 

  70. 
        //cin >> sendMsg;   

    71. 

  71.         gets(sendMsg);  
    72. 

  72. 
        if (!strcmp(sendMsg, "list"))     

    73. 

  73.         {     
    74. 

  74.             viewList();     
    75. 

  75.         }     
    76. 

  76. 
        else if (!strcmp(sendMsg, "exit"))     

    77. 

  77.         {     
    78. 

  78. 
            if (exitChatRoom())     

    79. 

  79.             {     
    80. 

  80. 
                break;     

    81. 

  81.             }     
    82. 

  82. 
            else     

    83. 

  83.             {     
    84. 

  84. 
                cout << "非安全退出..........." << endl;     

    85. 

  85.             }     
    86. 

  86.         }     
    87. 

  87. 
        else if (!strcmp(sendMsg, "help"))     

    88. 

  88.         {     
    89. 

  89. 
            cout << "*********************************" << endl;     

    90. 

  90. 
            cout << "[list] 命令查看在线用户列表" << endl;     

    91. 

  91. 
            cout << "[help] 命令查看帮助" << endl;     

    92. 

  92. 
            cout << "[exit] 命令退出聊天室" << endl;     

    93. 

  93. 
            cout << "*********************************" << endl;     

    94. 

  94.         }     
    95. 

  95. 
        else     

    96. 

  96.         {     
    97. 

  97.             sendMessage(sendMsg, strlen(sendMsg));     
    98. 

  98.         }     
    99. 

  99.          
    100. 

  100.     }     
    101. 

  101.     Sleep(2500);     
    102. 

  102.      
    103. 

  103. 
    if (!closesocket(sock))      

    104. 

  104.     {     
    105. 

  105.         WSAGetLastError();     
    106. 

  106. 
        return;     

    107. 

  107.     }     
    108. 

  108. 
    if (!WSACleanup())      

    109. 

  109.     {     
    110. 

  110.         WSAGetLastError();     
    111. 

  111. 
        return;     

    112. 

  112.     }        
    113. 

  113. }     
    114. 

  114.      
    115. 

  115. 
bool login()     

    116. 

  116. {     
    117. 

  117.     GramHead loginHead;     
    118. 

  118. 
    unsigned char name[LOGIN_NAME_LENGTH];     

    119. 

  119.  
    120. 

  120.     memset(name, 0, LOGIN_NAME_LENGTH);     
    121. 

  121.  
    122. 

  122. 
    cout << "输入你登录聊天室的用户名：" << endl;     

    123. 

  123.     cin >> loginHead.USERNO;     
    124. 

  124.     strcpy(loginName, loginHead.USERNO);     
    125. 

  125.  
    126. 

  126.     loginHead.COMMAND = C_LOGIN;     
    127. 

  127.     loginHead.LENGTH = BUFFER_SIZE;     
    128. 

  128.     loginHead.COUNT = 5;     
    129. 

  129.     loginHead.NO = 1;     
    130. 

  130.     loginHead.PACKID = 20;     
    131. 

  131.  
    132. 

  132. 
    unsigned char *szMsg = new unsigned char[BUFFER_SIZE];     

    133. 

  133.     memset(szMsg, 0, BUFFER_SIZE);    
    134. 

  134.       
    135. 

  135. 
    int nlen = sizeof(addrto);     

    136. 

  136. 
    memcpy(szMsg, &loginHead, sizeof(GramHead));    

    137. 

  137.         
    138. 

  138. 
    if (sendto(sock, (const char *)szMsg, sizeof(GramHead), 0, (sockaddr*)&addrto, nlen)     

    139. 

  139.         == SOCKET_ERROR)     
    140. 

  140.     {  
    141. 

  141. 
        cout << "login" << endl;  

    142. 

  142.         cout << WSAGetLastError() << endl;     
    143. 

  143.     }  
    144. 

  144. 
    else     

    145. 

  145.     {  
    146. 

  146. 
        cout << "正在登陆，请稍后......" << endl;     

    147. 

  147.     }  
    148. 

  148. 
    delete szMsg;     

    149. 

  149.      
    150. 

  150. 
    //接收到的SOCK地址      

    151. 

  151.     sockaddr_in from;     
    152. 

  152. 
    memset(&from, 0, sizeof(from));     

    153. 

  153.          
    154. 

  154. 
    int fromlength = sizeof(SOCKADDR);     

    155. 

  155. 
    char *buf = new char[BUFFER_SIZE];   

    156. 

  156.       
    157. 

  157.     Sleep(1000);     
    158. 

  158.  
    159. 

  159.     recvfrom(sock, buf, BUFFER_SIZE, 0,   
    160. 

  160. 
             (struct sockaddr FAR *)&from,   

    161. 

  161. 
             (int FAR *)&fromlength);    

    162. 

  162.       
    163. 

  163. 
    GramHead loginBack; //接收到的登陆返回包头      

    164. 

  164. 
    memcpy(&loginBack, buf, sizeof(GramHead));     

    165. 

  165.  
    166. 

  166. 
    if (loginBack.COMMAND == S_LOGIN)     

    167. 

  167.     {     
    168. 

  168. 
        cout << "登陆成功，欢迎你来到rangercyh的聊天室！" << endl;     

    169. 

  169. 
        delete buf;     

    170. 

  170.     }     
    171. 

  171. 
    else     

    172. 

  172.     {     
    173. 

  173. 
        delete buf;     

    174. 

  174. 
        return false;     

    175. 

  175.     }     
    176. 

  176. 
    return true;     

    177. 

  177. }     
    178. 

  178.      
    179. 

  179. 
void sendMessage(char *buf, int length)     

    180. 

  180. {     
    181. 

  181.     GramHead sendHead;    
    182. 

  182.       
    183. 

  183.     sendHead.COMMAND = C_MESSAGE;     
    184. 

  184.     strcpy(sendHead.USERNO, loginName);     
    185. 

  185.      
    186. 

  186. 
    unsigned char *szMsg = new unsigned char[BUFFER_SIZE];     

    187. 

  187.     memset(szMsg, 0, BUFFER_SIZE);     
    188. 

  188.  
    189. 

  189. 
    int nlen = sizeof(addrto);     

    190. 

  190. 
    memcpy(szMsg, &sendHead, sizeof(GramHead));     

    191. 

  191. 
    memcpy(szMsg + sizeof(GramHead), buf, length);     

    192. 

  192.          
    193. 

  193. 
    if (sendto(sock, (const char *)szMsg, sizeof(GramHead) + length, 0, (sockaddr*)&addrto, nlen)     

    194. 

  194.         == SOCKET_ERROR)   
    195. 

  195.     {  
    196. 

  196. 
        //cout << "sendMessage" << endl;  

    197. 

  197.         cout << WSAGetLastError() << endl;  
    198. 

  198.     }  
    199. 

  199. }     
    200. 

  200.      
    201. 

  201. 
//接收线程      

    202. 

  202. 
void RecvThread()     

    203. 

  203. {     
    204. 

  204. 
    //接收到的SOCK地址      

    205. 

  205.     sockaddr_in from;     
    206. 

  206.  
    207. 

  207. 
    memset(&from, 0, sizeof(from));     

    208. 

  208.          
    209. 

  209. 
    int fromlength = sizeof(SOCKADDR);     

    210. 

  210. 
    char *buf = new char[BUFFER_SIZE];     

    211. 

  211.  
    212. 

  212.     memset(buf, 0, BUFFER_SIZE);     
    213. 

  213.     Sleep(1000);   
    214. 

  214.       
    215. 

  215. 
    while (1)     

    216. 

  216.     {     
    217. 

  217.         Sleep(1000);     
    218. 

  218.  
    219. 

  219.         recvfrom(sock, buf, BUFFER_SIZE, 0,   
    220. 

  220. 
                 (struct sockaddr FAR *)&from,   

    221. 

  221. 
                 (int FAR *)&fromlength);     

    222. 

  222.  
    223. 

  223. 
        GramHead msgHead;   //接收到的登陆返回包头      

    224. 

  224. 
        memcpy(&msgHead, buf, sizeof(GramHead));    

    225. 

  225.           
    226. 

  226. 
        switch (msgHead.COMMAND)     

    227. 

  227.         {     
    228. 

  228. 
        case C_RECVMESSAGE:     //客户消息      

    229. 

  229. 
            cout << msgHead.USERNO << " 说道：" << buf + sizeof(GramHead) << endl;     

    230. 

  230. 
            break;     

    231. 

  231. 
        case S_MESSAGE:         //系统消息      

    232. 

  232. 
            cout << "系统消息:" << buf + sizeof(GramHead) << endl;     

    233. 

  233. 
            break;     

    234. 

  234. 
        case S_USERLIST:     

    235. 

  235. 
            cout << "--------------------------------" << endl;     

    236. 

  236. 
            cout << "当前在线用户为：" << endl;     

    237. 

  237. 
            cout << buf + sizeof(GramHead);     

    238. 

  238. 
            cout << "--------------------------------" << endl;     

    239. 

  239. 
            break;     

    240. 

  240. 
        case S_LOGOUT:     

    241. 

  241. 
            cout << ":::::系统提示:::::" << buf + sizeof(GramHead) << " 离开了聊天室......" << endl;     

    242. 

  242. 
            break;     

    243. 

  243. 
        case S_USERLOGIN:     

    244. 

  244. 
            cout << ":::::系统提示:::::" << buf + sizeof(GramHead) << " 进入了聊天室！" << endl;     

    245. 

  245. 
            break;     

    246. 

  246.         }     
    247. 

  247.         memset(buf, 0, BUFFER_SIZE);     
    248. 

  248.     }     
    249. 

  249. 
    delete buf;     

    250. 

  250. }     
    251. 

  251.      
    252. 

  252. 
void viewList()     

    253. 

  253. {     
    254. 

  254.     GramHead head;     
    255. 

  255.     head.COMMAND = C_USERLIST;     
    256. 

  256. 
    unsigned char *szMsg = new unsigned char[BUFFER_SIZE];    

    257. 

  257.       
    258. 

  258.     memset(szMsg, 0, BUFFER_SIZE);     
    259. 

  259.  
    260. 

  260. 
    int nlen = sizeof(addrto);     

    261. 

  261. 
    memcpy(szMsg, &head, sizeof(GramHead));     

    262. 

  262.          
    263. 

  263. 
    if (sendto(sock, (const char *)szMsg, sizeof(GramHead), 0, (sockaddr*)&addrto, nlen)     

    264. 

  264.         == SOCKET_ERROR)  
    265. 

  265.     {  
    266. 

  266. 
        //cout << "viewList" << endl;  

    267. 

  267.         cout << WSAGetLastError() << endl;    
    268. 

  268.     }  
    269. 

  269. 
    delete szMsg;     

    270. 

  270. }     
    271. 

  271.      
    272. 

  272. 
bool exitChatRoom()     

    273. 

  273. {     
    274. 

  274.     GramHead head;     
    275. 

  275.  
    276. 

  276.     head.COMMAND = C_LOGOUT;     
    277. 

  277.  
    278. 

  278. 
    unsigned char *szMsg = new unsigned char[BUFFER_SIZE];     

    279. 

  279.     memset(szMsg, 0, BUFFER_SIZE);     
    280. 

  280.  
    281. 

  281. 
    int nlen = sizeof(addrto);     

    282. 

  282. 
    memcpy(szMsg, &head, sizeof(GramHead));     

    283. 

  283.          
    284. 

  284. 
    if (sendto(sock, (const char *)szMsg, sizeof(GramHead), 0, (sockaddr*)&addrto, nlen)     

    285. 

  285.         == SOCKET_ERROR)     
    286. 

  286.     {     
    287. 

  287. 
        //cout << "exitChatRoom" << endl;  

    288. 

  288.         cout << WSAGetLastError() << endl;     
    289. 

  289. 
        delete szMsg;     

    290. 

  290. 
        return false;     

    291. 

  291.     }     
    292. 

  292. 
    delete szMsg;     

    293. 

  293. 
    return true;     

    294. 

  294. }   
    295. 



之前我一直有一个错误，我写的sendto()函数一直无法成功，总是返回SOCKET_ERROR，我调用WSAGetLastError()函数能够看到程序错误码是10038，用Error Lookup查看错误码显示如下：


编写一个基于控制台的聊天室程序


这意味着我sendto()函数的第一个参数存在问题，仔细检查后发现我的socket重定义了。唉～～人生不如意十有八九啊！果断改了，在编写过程中遇到很多这类问题，这里就不一一列举了，反正你也不爱听。


最后效果如图：


 


编写一个基于控制台的聊天室程序