├── Client.cpp
├── Client.h
├── ClientMain.cpp
├── Common.h
├── Makefile
├── README.md
├── Server.cpp
├── Server.h
└── ServerMain.cpp


/Client.cpp:
--------------------------------------------------------------------------------
  1 | #include"Client.h"
  2 | 
  3 | using namespace std;
  4 | 
  5 | //客户端类成员函数
  6 | //客户端类构造函数
  7 | Client::Client()
  8 | {
  9 | 	//初始化要连接的服务器地址和端口
 10 | 	serverAddr.sin_family = AF_INET;
 11 | 	serverAddr.sin_port = htons(SERVER_PORT);
 12 | 	inet_pton(AF_INET,SERVER_IP,&serverAddr.sin_addr.s_addr);
 13 | 	
 14 | 	//初始化socket
 15 | 	sock = 0;
 16 | 
 17 | 	//初始化进程号
 18 | 	pid = 0;
 19 | 
 20 | 	//客户端状态
 21 | 	isClientwork = true;
 22 | 
 23 | 	//epoll fd
 24 | 	epfd = 0;
 25 | }
 26 | 
 27 | //连接服务器
 28 | void Client::Connect()
 29 | {
 30 | 	cout<<"Connect Server: "<<SERVER_IP<<" : "<<SERVER_PORT<<endl;
 31 | 	
 32 | 	//创建socket
 33 | 	sock = socket(AF_INET,SOCK_STREAM,0);
 34 | 	if(sock<0)
 35 | 	{
 36 | 		perror("socker error: ");
 37 | 		exit(1);
 38 | 	}
 39 | 	
 40 | 	//连接服务端
 41 | 	if(connect(sock,(struct sockaddr*)&serverAddr,sizeof(serverAddr))<0)
 42 | 	{
 43 | 		perror("connect error: ");
 44 | 		exit(1);
 45 | 	}
 46 | 
 47 | 	//创建管道，其中fd[0]用于父进程读，fd[1]用于子进程写
 48 | 	if(pipe(pipe_fd)<0)
 49 | 	{
 50 | 		perror("pipe error:");
 51 | 		exit(1);
 52 | 	}
 53 | 
 54 | 	//创建epoll
 55 | 	epfd = epoll_create(EPOLL_SIZE);
 56 | 
 57 | 	if(epfd<0)
 58 | 	{
 59 | 		perror("epoll_create error:");
 60 | 		exit(1);
 61 | 	}
 62 | 
 63 | 	//将sock和管道读端描述符都添加到内核事件表中
 64 | 	addfd(epfd,sock,true);
 65 | 	addfd(epfd,pipe_fd[0],true);
 66 | }
 67 | 
 68 | //断开连接，清理并关闭文件描述符
 69 | void Client::Close()
 70 | {
 71 | 	if(pid)
 72 | 	{
 73 | 		//关闭父进程的管道和sock
 74 | 		close(pipe_fd[0]);
 75 | 		close(sock);
 76 | 	}else{
 77 | 		//关闭子进程的管道
 78 | 		close(pipe_fd[1]);
 79 | 	}
 80 | }
 81 | 
 82 | //启动客户端
 83 | void Client::Start()
 84 | {
 85 | 	//epoll 事件队列
 86 | 	static struct epoll_event events[2];
 87 | 
 88 | 	//连接服务器
 89 | 	Connect();
 90 | 
 91 | 	//创建子进程
 92 | 	pid = fork();
 93 | 	
 94 | 	//如果子进程失败则退吹
 95 | 	if(pid<0)
 96 | 	{
 97 | 		perror("fork error: ");
 98 | 		close(sock);
 99 | 		exit(1);
100 | 	}else if(pid == 0)
101 | 	{
102 | 		//进入子进程执行流程
103 | 		//子进程负责写入管道，因此先关闭读端
104 | 		close(pipe_fd[0]);
105 | 		
106 | 		//输入exit可以退出聊天室
107 | 		cout<<"Please input 'exit' to exit the chat room!"<<endl;
108 | 		cout<<"\\ + ClientID to private chat"<<endl;
109 | 	
110 | 		//如果客户端运行正常则不断读取输入发送给服务端
111 | 		while(isClientwork)
112 | 		{
113 | 			//清空结构体
114 | 			memset(msg.content,0,sizeof(msg.content));
115 | 			fgets(msg.content,BUF_SIZE,stdin);
116 | 			
117 | 			//如果客户输入exit,退出
118 | 			if(strncasecmp(msg.content,EXIT,strlen(EXIT))==0)
119 | 				isClientwork = 0;
120 | 			else	//子进程将信息写入管道
121 | 			{	
122 | 				//清空发送缓存
123 | 				memset(send_buf,0,BUF_SIZE);
124 | 				//结构体转换为字符串
125 | 				memcpy(send_buf,&msg,sizeof(msg));
126 | 				if(write(pipe_fd[1],send_buf,sizeof(send_buf))<0)
127 | 				{
128 | 					perror("fork error: ");
129 | 					exit(1);
130 | 				}
131 | 			}
132 | 		}	
133 | 	}else
134 | 	{
135 | 		//pid>0 父进程
136 | 		//父进程负责读管道数据,因此先关闭写端
137 | 		close(pipe_fd[1]);
138 | 
139 | 		//主循环epoll_wait
140 | 		while(isClientwork)
141 | 		{
142 | 			int epoll_events_count = epoll_wait(epfd,events,2,-1);
143 | 
144 | 			//处理就绪事件
145 | 			for(int i = 0;i<epoll_events_count;i++)
146 | 			{
147 | 				memset(recv_buf,0,sizeof(recv_buf));
148 | 				//服务端发来消息
149 | 				if(events[i].data.fd == sock)
150 | 				{
151 | 					//接收服务端广播消息
152 | 					int ret = recv(sock,recv_buf,BUF_SIZE,0);
153 | 					//清空结构体
154 | 					memset(&msg,0,sizeof(msg));
155 | 					//将发来的消息转换为结构体
156 | 					memcpy(&msg,recv_buf,sizeof(msg));
157 | 
158 | 					//ret = 0   服务端关闭
159 | 					if(ret == 0)
160 | 					{
161 | 						cout<<"Server closed connection: "<<sock<<endl;
162 | 						close(sock);
163 | 						isClientwork = 0;
164 | 					}else
165 | 						cout<<msg.content<<endl;
166 | 				}
167 | 				//子进程写入事件发生，父进程处理并发送服务端
168 | 				else
169 | 				{
170 | 					//父进程从管道中读取数据
171 | 					int ret = read(events[i].data.fd,recv_buf,BUF_SIZE);
172 | 					//ret = 0
173 | 					if(ret == 0)
174 | 						isClientwork = 0;
175 | 					else
176 | 						//将从管道中读取的字符串信息发送给服务端
177 | 						send(sock,recv_buf,sizeof(recv_buf),0);
178 | 				}
179 | 			}//for
180 | 		}//while
181 | 	}
182 | 	Close();         //退出进程
183 | }
184 | 


--------------------------------------------------------------------------------
/Client.h:
--------------------------------------------------------------------------------
 1 | #ifndef __CLIENT_H__
 2 | #define __CLIENT_H__
 3 | #include"Common.h"
 4 | using namespace std;
 5 | 
 6 | //客户端类，用来连接服务器发送和接收消息
 7 | class Client
 8 | {
 9 | public:
10 | 	//无参数构造函数
11 | 	Client();
12 | 
13 | 	//连接服务器
14 | 	void Connect();
15 | 
16 | 	//断开连接
17 | 	void Close();
18 | 
19 | 	//启动客户端
20 | 	void Start();
21 | private:
22 | 	//当前连接服务器端创建的socket
23 | 	int sock;
24 | 
25 | 	//当前进程ID
26 | 	pid_t pid;
27 | 
28 | 	//epoll_create创建后的返回值
29 | 	int epfd;
30 | 
31 | 	//创建管道，其中fd[0]用于父进程读，fd[1]用于子进程写
32 | 	int pipe_fd[2];
33 | 
34 | 	//表示客户端是否正常工作
35 | 	bool isClientwork;
36 | 
37 | 	//聊天信息
38 | 	Msg msg;
39 | 
40 | 	//结构体要转换为字符串
41 | 	char send_buf[BUF_SIZE];
42 | 	char recv_buf[BUF_SIZE];
43 | 
44 | 	//用户连接的服务器IP+port
45 | 	struct sockaddr_in serverAddr;
46 | };
47 | #endif
48 | 


--------------------------------------------------------------------------------
/ClientMain.cpp:
--------------------------------------------------------------------------------
 1 | #include"Client.h"
 2 | 
 3 | //客户端主函数
 4 | //创建客户端对象后启动客户端
 5 | int main()
 6 | {
 7 | 	Client client;
 8 | 	client.Start();
 9 | 	return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/Common.h:
--------------------------------------------------------------------------------
 1 | //公共头文件，包括所有需要的宏以及socket网络编程头文件，以及消息结构体(用来表示消息类别等)
 2 | #ifndef __COMMON_H__
 3 | #define __COMMON_H__
 4 | #include<iostream>
 5 | #include<stdio.h>
 6 | #include<stdlib.h>
 7 | #include<sys/socket.h>
 8 | #include<unistd.h>
 9 | #include<sys/epoll.h>
10 | #include<fcntl.h>
11 | #include<arpa/inet.h>
12 | #include<list>
13 | #include<string.h>
14 | 
15 | //默认服务器端IP地址
16 | #define SERVER_IP "127.0.0.1"
17 | 
18 | //服务器端口号
19 | #define SERVER_PORT 8888
20 | 
21 | //epoll支持的最大句柄数(建议数)
22 | #define EPOLL_SIZE 5000
23 | 
24 | //缓冲区大小(65535)
25 | #define BUF_SIZE 0XFFFF
26 | 
27 | //新用户登录后的欢迎信息
28 | #define SERVER_WELCOME "Welcome you join to the char room!Your chat ID is: Client %d"
29 | 
30 | //其他用户收到消息的前缀
31 | #define SERVER_MESSAGE "ClientID %d say >> %s"
32 | #define SERVER_PRIVATE_MESSAGE "Client %d say to you privately >> %s"
33 | #define SERVER_PRIVATE_ERROR_MESSAGE "Client %d is not in the chat room yet~"
34 | 
35 | //退出系统
36 | #define EXIT "EXIT"
37 | 
38 | //提醒你是聊天室中唯一的客户
39 | #define CAUTION "There is only one in the chat room!"
40 | 
41 | //注册新的fd到epollfd中
42 | //参数enable_et表示是否启用ET模式，如果为true则启用，否则使用LT模式
43 | static void addfd(int epollfd,int fd,bool enable_et)
44 | {
45 | 	struct epoll_event ev;
46 | 	ev.data.fd = fd;
47 | 	ev.events = EPOLLIN;
48 | 	if(enable_et)
49 | 		ev.events = EPOLLIN|EPOLLET;
50 | 	epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev);
51 | 	
52 | 	//设置socket为非阻塞模式(套接字立即返回，不管I/O是否完成，该函数所在的线程会继续运行)
53 | 	fcntl(fd,F_SETFL,fcntl(fd,F_GETFD,0)|O_NONBLOCK);
54 | 	printf("fd added to epoll!\n\n");	
55 | }
56 | 
57 | //定义信息结构，在服务端和客户端之间传送
58 | struct Msg
59 | {
60 | 	int type;             //消息类别
61 | 	int fromID;           //发送方FD
62 | 	int toID;           //接收方FD
63 | 	char content[BUF_SIZE];      //文字信息
64 | };
65 | #endif
66 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CXX = g++
 2 | 
 3 | all:ClientMain.cpp ServerMain.cpp Server.o Client.o
 4 | 	$(CXX) ServerMain.cpp Server.o -o chatroom_server
 5 | 	$(CXX) ClientMain.cpp Client.o -o chatroom_client
 6 | Server.o:Server.cpp Server.h Common.h
 7 | 	$(CXX) -c Server.cpp
 8 | Client.o:Client.cpp Client.h Common.h
 9 | 	$(CXX) -c Client.cpp
10 | 
11 | clean:
12 | 	rm -f *.o chatroom_server chatroom_client
13 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Instant_messaging_system
 2 | Linux C++ socket网络编程----------即时通信系统
 3 | 
 4 | 项目内容：
 5 |   本项目使用C ++实现一个具备服务器端和客户端即时通信且具有私聊功能的聊天室
 6 |   目的是学习C++网络开发的基本概念，同时也熟悉了Linux下的C++程序编译和简单MakeFile的编写
 7 | 需求分析：
 8 |   1.服务端：能够接受新的客户连接，并将每个客户端发来的信息，广播给对应的目标客户端
 9 |   2.客户端：能够连接服务器，并向服务器发送消息，同时可以接受服务器发来的消息
10 | 服务端：
11 |   1.支持多个客户端接入，实现聊天室基本功能
12 |   2.启动服务，建立监听端口等待客户端连接
13 |   3.使用epoll机制实现并发，增加效率
14 |   4.客户端连接时，发送欢迎消息，并存储连接记录
15 |   5.客户端发送消息时，根据消息类型，广播给所有用户(群聊)或者指定用户(私聊)
16 |   6.客户端请求退出时，对相应连接信息进行清理
17 | 客户端：
18 |   1.连接服务器
19 |   2.支持用户输入消息，发送给服务端
20 |   3.接受并显示服务端发来的消息
21 |   4.退出连接
22 | 客户端需要两个进程分别支持以下功能：
23 |  子进程：
24 |   1.等待用户输入信息
25 |   2.将聊天信息写入管道(pipe),并发送给父进程
26 |  父进程:
27 |   1.使用epoll机制接收服务端发来的消息，并显示给用户，使用户看到其他用户的信息
28 |   2.将子进程发送的聊天信息从管道(pipe)中读取出来，并发送给客户端
29 | 


--------------------------------------------------------------------------------
/Server.cpp:
--------------------------------------------------------------------------------
  1 | #include"Server.h"
  2 | 
  3 | using namespace std;
  4 | 
  5 | //服务器端类成员函数
  6 | //服务器端类构造函数
  7 | Server::Server()
  8 | {
  9 | 	//初始化服务器地址和端口
 10 | 	serverAddr.sin_family = AF_INET;
 11 | 	serverAddr.sin_port = htons(SERVER_PORT);
 12 | 	inet_pton(AF_INET,SERVER_IP,&serverAddr.sin_addr.s_addr);
 13 | 
 14 | 	//初始化socket	
 15 | 	listener = 0;
 16 | 
 17 | 	//初始化epfd
 18 | 	epfd = 0;
 19 | }
 20 | 
 21 | //初始化服务端并启动监听
 22 | void Server::Init()
 23 | {
 24 | 	cout<<"Init Server..."<<endl;
 25 | 	
 26 | 	//创建监听socket
 27 | 	listener = socket(AF_INET,SOCK_STREAM,0);
 28 | 	if(listener<0)
 29 | 	{
 30 | 		perror("socket error: ");
 31 | 		exit(1);
 32 | 	}
 33 | 
 34 | 	//绑定地址
 35 | 	if(bind(listener,(struct sockaddr*)&serverAddr,sizeof(serverAddr))<0)
 36 | 	{
 37 | 		perror("bind error: ");
 38 | 		exit(1);
 39 | 	}
 40 | 	
 41 | 	//监听
 42 | 	int ret = listen(listener,5);
 43 | 	if(ret<0)
 44 | 	{
 45 | 		perror("listen error: ");
 46 | 		exit(1);
 47 | 	}
 48 | 	
 49 | 	cout<<"Start to listen: "<<SERVER_IP<<endl;
 50 | 
 51 | 	//在内核中创建事件表  epfd是一个句柄(红黑树的树根)
 52 | 	epfd = epoll_create(EPOLL_SIZE);
 53 | 	if(epfd<0)
 54 | 	{
 55 | 		perror("epoll_create error: ");
 56 | 		exit(1);
 57 | 	}
 58 | 
 59 | 	//往事件表里添加监听事件
 60 | 	addfd(epfd,listener,true);	
 61 | }
 62 | 
 63 | //关闭服务，清理并关闭文件描述符
 64 | void Server::Close()
 65 | {
 66 | 	close(listener);        //关闭listener
 67 | 
 68 | 	close(epfd);            //关闭epfd
 69 | }
 70 | 
 71 | //发送广播给所有客户端
 72 | int Server::SendBroadcastMessage(int clientfd)
 73 | {
 74 | 	char recv_buf[BUF_SIZE];
 75 | 	char send_buf[BUF_SIZE];
 76 | 	
 77 | 	Msg msg;
 78 | 	bzero(recv_buf,BUF_SIZE);
 79 | 		
 80 | 	//接受新消息
 81 | 	cout<<"read from client(clientID = "<<clientfd<<")"<<endl;
 82 | 	int len = recv(clientfd,recv_buf,BUF_SIZE,0);
 83 | 	
 84 | 	//清空结构体，把接受到的字符串转换为结构体
 85 | 	memset(&msg,0,sizeof(msg));
 86 | 	memcpy(&msg,recv_buf,sizeof(msg));
 87 | 
 88 | 	//判断接受到的信息是私聊还是群聊
 89 | 	msg.fromID = clientfd;
 90 | 	if(msg.content[0]=='\\'&&isdigit(msg.content[1]))
 91 | 	{
 92 | 		msg.type = 1;
 93 | 		msg.toID = msg.content[1] - '0';
 94 | 		memcpy(msg.content,msg.content+2,sizeof(msg.content));
 95 | 	}else
 96 | 	{
 97 | 		msg.type = 0;
 98 | 	}
 99 | 
100 | 	//如果客户端关闭了连接
101 | 	if(len == 0)
102 | 	{
103 | 		close(clientfd);
104 | 
105 | 		//在客户端列表中删除该客户端
106 | 		clients_list.remove(clientfd);
107 | 		cout<<"ClientID = "<<clientfd<<" close"<<endl;
108 | 		cout<<"now there are "<<clients_list.size()<<" client in the chat room"<<endl;
109 | 	}
110 | 
111 | 	//发送广播消息给所有客户端
112 | 	else
113 | 	{
114 | 		//判断聊天室是否还有其它客户端
115 | 		if(clients_list.size()==1)
116 | 		{
117 | 			//发送提示消息
118 | 			memcpy(msg.content,CAUTION,sizeof(msg.content));
119 | 			bzero(send_buf,BUF_SIZE);
120 | 			memcpy(send_buf,&msg,sizeof(msg));
121 | 			send(clientfd,send_buf,sizeof(send_buf),0);
122 | 			return len;
123 | 		}
124 | 		
125 | 		//存放格式化后的信息
126 | 		char format_message[BUF_SIZE];
127 | 
128 | 		//群聊
129 | 		if(msg.type == 0)
130 | 		{	
131 | 			//格式化发送的消息内容
132 | 			sprintf(format_message,SERVER_MESSAGE,clientfd,msg.content);
133 | 			memcpy(msg.content,format_message,BUF_SIZE);
134 | 			
135 | 			//遍历客户端列表依次发送消息，需要判断不要给来源客户端发
136 | 			list<int>::iterator it;
137 | 			for(it = clients_list.begin();it!=clients_list.end();it++)
138 | 			{
139 | 				if(*it != clientfd)
140 | 				{
141 | 					//把发送的结构体转换为字符串
142 | 					bzero(send_buf,BUF_SIZE);
143 | 					memcpy(send_buf,&msg,sizeof(msg));
144 | 					if(send(*it,send_buf,sizeof(send_buf),0)<0)
145 | 						return -1;
146 | 				}
147 | 
148 | 			}
149 | 		}
150 | 
151 | 		//私聊
152 | 		if(msg.type == 1)
153 | 		{
154 | 			bool private_offline = true;
155 | 			sprintf(format_message,SERVER_PRIVATE_MESSAGE,clientfd,msg.content);
156 | 			memcpy(msg.content,format_message,BUF_SIZE);
157 | 			
158 | 			//遍历客户端列表发送对应消息，需要判断不要给来源客户端发
159 | 			list<int>::iterator it;
160 | 			for(it = clients_list.begin();it!=clients_list.end();it++)
161 | 			{
162 | 				if(*it == msg.toID)
163 | 				{
164 | 					private_offline = false;
165 | 					//把发送的结构体转换为字符串
166 | 					bzero(send_buf,BUF_SIZE);
167 | 					memcpy(send_buf,&msg,sizeof(msg));
168 | 					if(send(*it,send_buf,sizeof(send_buf),0)<0)
169 | 						return -1;
170 | 				}
171 | 			}
172 | 
173 | 			//如果私聊对象不在线
174 | 			if(private_offline)
175 | 			{
176 | 				sprintf(format_message,SERVER_PRIVATE_ERROR_MESSAGE,msg.toID);
177 | 				memcpy(msg.content,format_message,BUF_SIZE);
178 | 				bzero(send_buf,BUF_SIZE);
179 | 				memcpy(send_buf,&msg,sizeof(msg));
180 | 				if(send(msg.fromID,send_buf,sizeof(send_buf),0)<0)
181 | 					return -1;
182 | 			}
183 | 		}
184 | 	}
185 | 	return len;
186 | }
187 | 
188 | //启动服务端
189 | void Server::Start()
190 | {
191 | 	//epoll 事件队列
192 | 	static struct epoll_event events[EPOLL_SIZE];
193 | 
194 | 	//初始化服务端
195 | 	Init();
196 | 
197 | 	//主循环
198 | 	while(1)
199 | 	{
200 | 		//epoll_events_count表示就绪事件的数目
201 | 		int epoll_events_count = epoll_wait(epfd,events,EPOLL_SIZE,-1);
202 | 		if(epoll_events_count<0)
203 | 		{
204 | 			perror("epoll_wait error: ");
205 | 			break;
206 | 		}
207 | 		
208 | 		cout<<"epoll_events_count = "<<epoll_events_count<<endl;
209 | 		
210 | 		//处理epoll_events_count个就绪事件
211 | 		for(int i = 0;i<epoll_events_count;i++)
212 | 		{	
213 | 			int sockfd = events[i].data.fd;
214 | 			
215 | 			//新用户连接
216 | 			if(sockfd == listener)
217 | 			{
218 | 				struct sockaddr_in client_addr;
219 | 				socklen_t client_addr_len = sizeof(client_addr);
220 | 				char client_IP[BUFSIZ];
221 | 				int clientfd = accept(listener,(struct sockaddr*)&client_addr,&client_addr_len);
222 | 				cout<<"client connection from: "<<inet_ntop(AF_INET,&client_addr.sin_addr.s_addr,client_IP,sizeof(client_IP))<<" : "<<ntohs(client_addr.sin_port)<<",clientfd = "<<clientfd<<endl;
223 | 				
224 | 				addfd(epfd,clientfd,true);
225 | 
226 | 				//服务端用list保存用户连接
227 | 				clients_list.push_back(clientfd);
228 | 				cout<<"Add new clientfd = "<<clientfd<<" to poll"<<endl;
229 | 				cout<<"Now there are "<<clients_list.size()<<"clients in the chat room!"<<endl;
230 | 				
231 | 				//服务端发送欢迎信息
232 | 				cout<<"Welcome message"<<endl;
233 | 				char message[BUF_SIZE];
234 | 				bzero(message,BUF_SIZE);
235 | 				sprintf(message,SERVER_WELCOME,clientfd);
236 | 				int ret = send(clientfd,message,BUF_SIZE,0);
237 | 				if(ret<0)
238 | 				{
239 | 					perror("send error: ");
240 | 					Close();
241 | 					exit(1);
242 | 				}
243 | 
244 | 
245 | 			}
246 | 			//处理用户发来的信息并广播，使其他用户收到信息
247 | 			else
248 | 			{
249 | 				int ret = SendBroadcastMessage(sockfd);
250 | 				if(ret<0)
251 | 				{
252 | 					perror("error: ");
253 | 					Close();
254 | 					exit(1);
255 | 				}
256 | 			}
257 | 		}	
258 | 	}
259 | 	//关闭服务
260 | 	Close();
261 | }
262 | 


--------------------------------------------------------------------------------
/Server.h:
--------------------------------------------------------------------------------
 1 | #ifndef __SERVER_H__
 2 | #define __SERVER_H__
 3 | #include"Common.h"
 4 | 
 5 | using namespace std;
 6 | 
 7 | //服务端类，用来处理客户端请求
 8 | class Server
 9 | {
10 | public:
11 | 	Server();              //无参数构造函数
12 | 	
13 | 	void Init();           //初始化服务端设置
14 | 
15 | 	void Close();         //关闭服务
16 | 
17 | 	void Start();         //启动服务端
18 | private:
19 | 	int SendBroadcastMessage(int clientfd);       //广播消息给所有客户端
20 | 
21 | 	struct sockaddr_in serverAddr;              //服务器端serverAddr信息
22 | 
23 | 	int listener;                              //创建监听的socket
24 | 
25 | 	int epfd;                                //epoll_create创建后的返回值
26 | 
27 | 	list<int> clients_list;                   //客户端列表
28 | };
29 | #endif
30 | 


--------------------------------------------------------------------------------
/ServerMain.cpp:
--------------------------------------------------------------------------------
 1 | #include"Server.h"
 2 | 
 3 | //服务端主函数
 4 | //创建服务端对象后启动服务端
 5 | 
 6 | int main()
 7 | {
 8 | 	Server server;
 9 | 	server.Start();
10 | 	return 0;
11 | }
12 | 


--------------------------------------------------------------------------------