UNIX网络编程——select函数的并发限制和 poll 函数应用举例

http://blog.csdn.net/chenxun_2010/article/details/50489577

一、用select实现的并发服务器，能达到的并发数，受两方面限制


       1、一个进程能打开的最大文件描述符限制。这可以通过调整内核参数。可以通过ulimit -n来调整或者使用setrlimit函数设置， 但一个系统所能打开的最大数也是有限的，跟内存大小有关，可以通过cat /proc/sys/fs/file-max 查看

       2、select中的fd_set集合容量的限制（FD_SETSIZE，一般为1024） ，这需要重新编译内核。


可以写个测试程序，只建立连接，看看最多能够建立多少个连接，客户端程序如下：

[cpp] view plaincopy
  1. #include <sys/types.h>  
  2. #include <sys/socket.h>  
  3. #include <netinet/in.h>  
  4. #include <arpa/inet.h>  
  5. #include <signal.h>  
  6. #include <stdlib.h>  
  7. #include <stdio.h>  
  8. #include <errno.h>  
  9. #include <string.h>  
  10.   
  11. #define ERR_EXIT(m) \  
  12.         do \  
  13.         { \  
  14.                 perror(m); \  
  15.                 exit(EXIT_FAILURE); \  
  16.         } while(0)  
  17.   
  18.   
  19. int main(void)  
  20. {  
  21.     int count = 0;  
  22.     while(1)  
  23.     {  
  24.         int sock;  
  25.         if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  26.         {  
  27.             sleep(4);  
  28.             ERR_EXIT("socket");  
  29.         }  
  30.   
  31.         struct sockaddr_in servaddr;  
  32.         memset(&servaddr, 0, sizeof(servaddr));  
  33.         servaddr.sin_family = AF_INET;  
  34.         servaddr.sin_port = htons(5188);  
  35.         servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
  36.   
  37.         if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
  38.             ERR_EXIT("connect");  
  39.   
  40.         struct sockaddr_in localaddr;  
  41.         socklen_t addrlen = sizeof(localaddr);  
  42.         if (getsockname(sock, (struct sockaddr *)&localaddr, &addrlen) < 0)  
  43.             ERR_EXIT("getsockname");  
  44.   
  45.         printf("ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));  
  46.         printf("count = %d\n", ++count);  
  47.   
  48.     }  
  49.   
  50.     return 0;  
  51. }  
服务器的代码serv.c

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<sys/types.h>  
  3. #include<sys/socket.h>  
  4. #include<unistd.h>  
  5. #include<stdlib.h>  
  6. #include<errno.h>  
  7. #include<arpa/inet.h>  
  8. #include<netinet/in.h>  
  9. #include<string.h>  
  10. #include<signal.h>  
  11. #include<sys/wait.h>  
  12.   
  13.   
  14.   
  15. #define ERR_EXIT(m) \  
  16.     do { \  
  17.         perror(m); \  
  18.         exit(EXIT_FAILURE); \  
  19.     } while (0)  
  20.   
  21.   
  22. int main(void)  
  23. {  
  24.       
  25.     signal(SIGPIPE, SIG_IGN);  
  26.     int listenfd; //被动套接字(文件描述符），即只可以accept, 监听套接字  
  27.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  28. //  listenfd = socket(AF_INET, SOCK_STREAM, 0)    
  29.         ERR_EXIT("socket error");  
  30.   
  31.     struct sockaddr_in servaddr;  
  32.     memset(&servaddr, 0, sizeof(servaddr));  
  33.     servaddr.sin_family = AF_INET;  
  34.     servaddr.sin_port = htons(5188);  
  35.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   
  36.     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */  
  37.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
  38.       
  39.     int on = 1;  
  40.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)  
  41.         ERR_EXIT("setsockopt error");  
  42.   
  43.     if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)  
  44.         ERR_EXIT("bind error");  
  45.   
  46.     if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前  
  47.         ERR_EXIT("listen error");  
  48.       
  49.     struct sockaddr_in peeraddr; //传出参数  
  50.     socklen_t peerlen = sizeof(peeraddr); //传入传出参数，必须有初始值  
  51.       
  52.     int conn; // 已连接套接字(变为主动套接字，即可以主动connect)  
  53.     int i;  
  54.     int client[FD_SETSIZE];  
  55.     int maxi = 0; // client数组中最大不空闲位置的下标  
  56.     for (i = 0; i < FD_SETSIZE; i++)  
  57.         client[i] = -1;  
  58.   
  59.     int nready;  
  60.     int maxfd = listenfd;  
  61.     fd_set rset;  
  62.     fd_set allset;  
  63.     FD_ZERO(&rset);  
  64.     FD_ZERO(&allset);  
  65.     FD_SET(listenfd, &allset);  
  66.   
  67.     int count = 0;  
  68.     while (1) {  
  69.         rset = allset;  
  70.         nready = select(maxfd + 1, &rset, NULL, NULL, NULL);  
  71.         if (nready == -1) {  
  72.             if (errno == EINTR)  
  73.                 continue;  
  74.             ERR_EXIT("select error");  
  75.         }  
  76.   
  77.         if (nready == 0)  
  78.             continue;  
  79.   
  80.         if (FD_ISSET(listenfd, &rset)) {  
  81.           
  82.             conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);  //accept不再阻塞  
  83.             if (conn == -1)  
  84.                 ERR_EXIT("accept error");  
  85.             printf("count = %d\n", ++count);  
  86.             for (i = 0; i < FD_SETSIZE; i++) {  
  87.                 if (client[i] < 0) {  
  88.                     client[i] = conn;  
  89.                     if (i > maxi)  
  90.                         maxi = i;  
  91.                     break;  
  92.                 }   
  93.             }  
  94.               
  95.             if (i == FD_SETSIZE) {  
  96.                 fprintf(stderr, "too many clients\n");  
  97.                 exit(EXIT_FAILURE);  
  98.             }  
  99.   
  100.             printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),  
  101.                 ntohs(peeraddr.sin_port));  
  102.   
  103.             FD_SET(conn, &allset);  
  104.             if (conn > maxfd)  
  105.                 maxfd = conn;  
  106.   
  107.             if (--nready <= 0)  
  108.                 continue;  
  109.         }  
  110.   
  111.         for (i = 0; i <= maxi; i++) {  
  112.             conn = client[i];  
  113.             if (conn == -1)  
  114.                 continue;  
  115.   
  116.             if (FD_ISSET(conn, &rset)) {  
  117.                   
  118.                 char recvbuf[1024] = {0};  
  119.                 int ret = read(conn, recvbuf, 1024);  
  120.                 if (ret == -1)  
  121.                     ERR_EXIT("read error");  
  122.                 else if (ret  == 0) { //客户端关闭   
  123.                     printf("client close \n");  
  124.                     FD_CLR(conn, &allset);  
  125.                     client[i] = -1;  
  126.                     close(conn);  
  127.                 }  
  128.           
  129.                 fputs(recvbuf, stdout);  
  130.                 write(conn, recvbuf, strlen(recvbuf));  
  131.                   
  132.                 if (--nready <= 0)  
  133.                     break;   
  134.             }  
  135.         }  
  136.   
  137.   
  138.     }  
  139.           
  140.     return 0;  
  141. }  
  142.   
  143. /* select所能承受的最大并发数受 
  144.  * 1.一个进程所能打开的最大文件描述符数，可以通过ulimit -n来调整 
  145.  *   但一个系统所能打开的最大数也是有限的，跟内存有关，可以通过cat /proc/sys/fs/file-max 查看 
  146.  * 2.FD_SETSIZE(fd_set)的限制，这个需要重新编译内核                                                                           
  147.  */  


huangcheng@ubuntu:~$ ./serv  
count = 1  
recv connect ip=127.0.0.1 port=48370  
count = 2  
recv connect ip=127.0.0.1 port=48371  
count = 3  
recv connect ip=127.0.0.1 port=48372  
count = 4  
recv connect ip=127.0.0.1 port=48373  
....................................  
recv connect ip=127.0.0.1 port=49389  
count = 1020  
recv connect ip=127.0.0.1 port=49390  



accept error: Too many open files  
[cpp] view plaincopyprint?
huangcheng@ubuntu:~$ ./cli  
ip=127.0.0.1 port=46327  
count = 1  
ip=127.0.0.1 port=46328  
count = 2  
ip=127.0.0.1 port=46329  
count = 3  
ip=127.0.0.1 port=46330  
count = 4  
ip=127.0.0.1 port=46331  
count = 5  
ip=127.0.0.1 port=46332  
count = 6  
ip=127.0.0.1 port=46333  
.......................  
ip=127.0.0.1 port=47345  
count = 1020  
ip=127.0.0.1 port=47346  
count = 1021  
socket: Too many open files  


输出太多条目，上面只截取最后几条，从中可以看出对于客户端，最多只能开启1021个连接套接字，因为总共是1024个，还得除去0、1、2。而服务器端只能accept 返回1020个已连接套接字，因为除了0、1、2之外还有一个监听套接字，客户端某一个套接字（不一定是最后一个）虽然已经建立了连接，在已完成连接队列中，但accept 返回时达到最大描述符限制，返回错误，打印提示信息。


       也许有人会注意到上面有一行 sleep(4)；当客户端调用socket准备创建第1022个套接字时，如上所示也会提示错误，此时socket函数返回-1出错，如果没有睡眠4s后再退出进程会有什么问题呢？如果直接退出进程，会将客户端所打开的所有套接字关闭掉，即向服务器端发送了很多FIN段，而此时也许服务器端还一直在accept ，即还在从已连接队列中返回已连接套接字，此时服务器端除了关心监听套接字的可读事件，也开始关心前面已建立连接的套接字的可读事件，read 返回0，所以会有很多 client close 字段 参杂在条目的输出中，还有个问题就是，因为read 返回0，服务器端会将自身的已连接套接字关闭掉，那么也许刚才说的客户端某一个连接会被accept 返回，即测试不出服务器端真正的并发容量。

  1. huangcheng@ubuntu:~$ ./serv  
  2. count = 1  
  3. recv connect ip=127.0.0.1 port=50413  
  4. count = 2  
  5. ....................................  
  6. client close  
  7. client close  
  8. client close  
  9. client close  
  10. ...................................  
  11. recv connect ip=127.0.0.1 port=51433  
  12. client close  
  13. count = 1021  
  14. recv connect ip=127.0.0.1 port=51364  
  15. client close  
  16. client close  
      可以看到输出参杂着client close，且这次的count 达到了1021，原因就是服务器端前面已经有些套接字关闭了，所以accept 创建套接字不会出错，服务器进程也不会因为出错而退出，可以看到最后接收到的一个连接端口是51364，即不一定是客户端的最后一个连接。

二、poll 函数应用举例


[cpp] view plaincopy
  1. #include <poll.h>  
  2. int poll(struct pollfd *fds, nfds_t nfds, int timeout);  
参数1：结构体数组指针

[cpp] view plaincopy
  1. struct pollfd {  
  2.     int   fd;         /* file descriptor */  
  3.     short events;     /* requested events */  
  4.     short revents;    /* returned events */  
  5. };  

结构体中的fd 即套接字描述符，events 即感兴趣的事件，如下图所示，revents 即返回的事件。


参数2：结构体数组的成员个数，即文件描述符个数。

参数3：即超时时间，若为-1，表示永不超时。


       poll 跟 select 还是很相似的，比较重要的区别在于poll 所能并发的个数跟FD_SETSIZE无关，只跟一个进程所能打开的文件描述符个数有关，可以在select 程序的基础上修改成poll 程序，在运行服务器端程序之前，使用ulimit -n 2048 将限制改成2048个，注意在运行客户端进程的终端也需更改，因为客户端也会有所限制，这只是临时性的更改，因为子进程会继承这个环境参数，而我们是在bash命令行启动程序的，故在进程运行期间，文件描述符的限制为2048个。

使用poll 函数的服务器端程序如下：

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<sys/types.h>  
  3. #include<sys/socket.h>  
  4. #include<unistd.h>  
  5. #include<stdlib.h>  
  6. #include<errno.h>  
  7. #include<arpa/inet.h>  
  8. #include<netinet/in.h>  
  9. #include<string.h>  
  10. #include<signal.h>  
  11. #include<sys/wait.h>  
  12. #include<poll.h>  
  13.   
  14. #define ERR_EXIT(m) \  
  15.     do { \  
  16.         perror(m); \  
  17.         exit(EXIT_FAILURE); \  
  18.     } while (0)  
  19.   
  20.   
  21. int main(void)  
  22. {  
  23.     int count = 0;  
  24.     signal(SIGPIPE, SIG_IGN);  
  25.     int listenfd; //被动套接字(文件描述符），即只可以accept, 监听套接字  
  26.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
  27.         //  listenfd = socket(AF_INET, SOCK_STREAM, 0)  
  28.         ERR_EXIT("socket error");  
  29.   
  30.     struct sockaddr_in servaddr;  
  31.     memset(&servaddr, 0, sizeof(servaddr));  
  32.     servaddr.sin_family = AF_INET;  
  33.     servaddr.sin_port = htons(5188);  
  34.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  35.     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */  
  36.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
  37.   
  38.     int on = 1;  
  39.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)  
  40.         ERR_EXIT("setsockopt error");  
  41.   
  42.     if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
  43.         ERR_EXIT("bind error");  
  44.   
  45.     if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前  
  46.         ERR_EXIT("listen error");  
  47.   
  48.     struct sockaddr_in peeraddr; //传出参数  
  49.     socklen_t peerlen = sizeof(peeraddr); //传入传出参数，必须有初始值  
  50.   
  51.     int conn; // 已连接套接字(变为主动套接字，即可以主动connect)  
  52.     int i;  
  53.   
  54.     struct pollfd client[2048];  
  55.     int maxi = 0; //client[i]最大不空闲位置的下标  
  56.   
  57.     for (i = 0; i < 2048; i++)  
  58.         client[i].fd = -1;  
  59.   
  60.     int nready;  
  61.     client[0].fd = listenfd;  
  62.     client[0].events = POLLIN;  
  63.   
  64.     while (1)  
  65.     {  
  66.         /* poll检测[0, maxi + 1) */  
  67.         nready = poll(client, maxi + 1, -1);  
  68.         if (nready == -1)  
  69.         {  
  70.             if (errno == EINTR)  
  71.                 continue;  
  72.             ERR_EXIT("poll error");  
  73.         }  
  74.   
  75.         if (nready == 0)  
  76.             continue;  
  77.   
  78.         if (client[0].revents & POLLIN)  
  79.         {  
  80.   
  81.             conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen); //accept不再阻塞  
  82.             if (conn == -1)  
  83.                 ERR_EXIT("accept error");  
  84.   
  85.             for (i = 1; i < 2048; i++)  
  86.             {  
  87.                 if (client[i].fd < 0)  
  88.                 {  
  89.                     client[i].fd = conn;  
  90.                     if (i > maxi)  
  91.                         maxi = i;  
  92.                     break;  
  93.                 }  
  94.             }  
  95.   
  96.             if (i == 2048)  
  97.             {  
  98.                 fprintf(stderr, "too many clients\n");  
  99.                 exit(EXIT_FAILURE);  
  100.             }  
  101.   
  102.             printf("count = %d\n", ++count);  
  103.             printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),  
  104.                    ntohs(peeraddr.sin_port));  
  105.   
  106.             client[i].events = POLLIN;  
  107.   
  108.             if (--nready <= 0)  
  109.                 continue;  
  110.         }  
  111.   
  112.         for (i = 1; i <= maxi; i++)  
  113.         {  
  114.             conn = client[i].fd;  
  115.             if (conn == -1)  
  116.                 continue;  
  117.             if (client[i].revents & POLLIN)  
  118.             {  
  119.   
  120.                 char recvbuf[1024] = {0};  
  121.                 int ret = read(conn, recvbuf, 1024);  
  122.                 if (ret == -1)  
  123.                     ERR_EXIT("readline error");  
  124.                 else if (ret  == 0)   //客户端关闭  
  125.                 {  
  126.                     printf("client  close \n");  
  127.                     client[i].fd = -1;  
  128.                     close(conn);  
  129.                 }  
  130.   
  131.                 fputs(recvbuf, stdout);  
  132.                 write(conn, recvbuf, strlen(recvbuf));  
  133.   
  134.                 if (--nready <= 0)  
  135.                     break;  
  136.             }  
  137.         }  
  138.   
  139.   
  140.     }  
  141.   
  142.     return 0;  
  143. }  
  144.   
  145. /* poll 只受一个进程所能打开的最大文件描述符限制，这个可以使用ulimit -n调整 */  

参照前面对 select 函数 的解释不难理解上面的程序，就不再赘述了。来看一下输出：


[cpp] view plaincopy
  1. root@ubuntu:/home/huangcheng# ulimit -n 2048  
  2. root@ubuntu:/home/huangcheng# su - huangcheng  
  3. huangcheng@ubuntu:~$ ulimit -n  
  4. 2048  
  5. huangcheng@ubuntu:~$ ./serv  
  6. ...........................  
  7. count = 2042  
  8. recv connect ip=127.0.0.1 port=54499  
  9. count = 2043  
  10. recv connect ip=127.0.0.1 port=54500  
  11. count = 2044  
  12. recv connect ip=127.0.0.1 port=54501  
  13. accept error: Too many open files  
[cpp] view plaincopy
  1. root@ubuntu:/home/huangcheng# ulimit -n 2048  
  2. root@ubuntu:/home/huangcheng# su - huangcheng  
  3. huangcheng@ubuntu:~$ ulimit -n  
  4. 2048  
  5. huangcheng@ubuntu:~$./cli  
  6. ..........................  
  7. ip=127.0.0.1 port=54499  
  8. count = 2043  
  9. ip=127.0.0.1 port=54500  
  10. count = 2044  
  11. ip=127.0.0.1 port=54501  
  12. count = 2045  
  13. socket: Too many open files  
       可以看到现在最大的连接数已经是2045个了，虽然服务器端有某个连接没有accept 返回。即poll 比 select 能够承受更多的并发连接，只受一个进程所能打开的最大文件描述符个数限制。可以通过ulimit -n  修改，但一个系统所能打开的文件描述符个数也是有限的，这跟系统的内存大小有关系，所以说也不是可以无限地并 发，可以查看一下本机的容量：

[cpp] view plaincopy
  1. huangcheng@ubuntu:~$ cat /proc/sys/fs/file-max  
  2. 101598  
本机是虚拟机，内存2G，能够打开的文件描述符个数大约在10w个左右。


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383842.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【Java学习笔记二】继承和多态

【Java学习笔记二】继承和多态

与C不同的是&#xff0c;在Java中&#xff0c;一个类只能直接继承另一个类&#xff0c;而不允许继承多个类&#xff0c;这个新类称为继承类、派生类或者子类&#xff0c;而被继承的类称为基类或者父类。 继承类能够继承基类的群不属性和行为。 面向对象程序设计的三大特点为&…
阅读更多...
Linux系统编程——线程池

Linux系统编程——线程池

http://blog.csdn.net/tennysonsky/article/details/46490099# 线程池基本原理 在传统服务器结构中&#xff0c;常是有一个总的监听线程监听有没有新的用户连接服务器&#xff0c;每当有一个新的用户进入&#xff0c;服务器就开启一个新的线程用户处理这 个用户的数据包。这个线…
阅读更多...
简单Linux C线程池

简单Linux C线程池

http://www.cnblogs.com/venow/archive/2012/11/22/2779667.html 大多数的网络服务器&#xff0c;包括Web服务器都具有一个特点&#xff0c;就是单位时间内必须处理数目巨大的连接请求&#xff0c;但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的&#xff1…
阅读更多...
IO多路复用之poll总结

IO多路复用之poll总结

http://www.cnblogs.com/Anker/p/3261006.html 1、基本知识 poll的机制与select类似&#xff0c;与select在本质上没有多大差别&#xff0c;管理多个描述符也是进行轮询&#xff0c;根据描述符的状态进行处理&#xff0c;但是poll没有最大文件描述符数量的限制。poll和select同…
阅读更多...
【C++学习笔记二】C++继承

【C++学习笔记二】C++继承

继承 继承允许我们一句另一个类来定义一个类&#xff0c;这使得继承和维护一个程序变得更加容易&#xff0c;也达到了重用代码功能和提高执行效率的效果。 一般格式为&#xff1a; class 派生类名 :访问修饰符 基类名{};其中访问修饰符是public protected private中的一个&a…
阅读更多...
处理大并发之二 对epoll的理解，epoll客户端服务端代码

处理大并发之二 对epoll的理解，epoll客户端服务端代码

http://blog.csdn.net/wzjking0929/article/details/51838370 序言&#xff1a; 该博客是一系列的博客&#xff0c;首先从最基础的epoll说起&#xff0c;然后研究libevent源码及使用方法&#xff0c;最后研究nginx和node.js&#xff0c;关于select,poll这里不做说明&#xff0c…
阅读更多...
C++基类指针指向派生类（指针）

C++基类指针指向派生类（指针）

我们常用基类指针指向派生类对象来实现多态性。 私有继承不允许基类指针指向派生类 基类指针只能访问到基类中含有的公有成员。 当用基类指针指向派生类对象在动态分配堆上内存的时候&#xff0c;析构函数必须是虚函数! 成员如果是数据成员的话访问的是基类的版本&#xff…
阅读更多...
一个简单的linux线程池

一个简单的linux线程池

http://blog.csdn.net/wzjking0929/article/details/20312675 线程池&#xff1a;简单地说&#xff0c;线程池 就是预先创建好一批线程&#xff0c;方便、快速地处理收到的业务。比起传统的到来一个任务&#xff0c;即时创建一个线程来处理&#xff0c;节省了线程的创建和回收的…
阅读更多...
C++制表符

C++制表符

制表符的转义字符为\t&#xff0c;一般情况下长度为8个空格&#xff0c;这里的8个指的是从上一个字符串的开头开始算&#xff0c;往后数8个&#xff0c;不够的话就补空格。 如果前面的字符串的长度大于等于8个&#xff0c;例如前面字符串的长度为x,那么就会补(8-x%8)个空格 例…
阅读更多...
C++派生类含有成员对象构造函数析构函数顺序

C++派生类含有成员对象构造函数析构函数顺序

参考博客&#xff1a;传送门1 当类中含有对象成员时&#xff1a; 类的构造函数要包含对成员对象的初始化&#xff0c;如果构造函数的成员初始化列表没有包含对成员对象的初始化&#xff0c;系统会自动调用成员对象的无参构造函数。顺序上&#xff1a;先调用成员对象的构造函数…
阅读更多...
链表逆序的原理及实例

链表逆序的原理及实例

http://blog.csdn.net/wangqing_12345/article/details/51757294 尾插法建立链表&#xff0c;带头结点设链表节点为typedef struct node {int data;struct node *next;}node_t, *pnode_t;要求将一带链表头List head的单向链表逆序。 分析&#xff1a; 1). 若链表为空或只有一个…
阅读更多...
C++关于虚基类、构造函数、析构函数、成员对象的两个程序浅析

C++关于虚基类、构造函数、析构函数、成员对象的两个程序浅析

预备博客&#xff1a; C虚继承中构造函数和析构函数顺序问题以及原理 C派生类含有成员对象构造函数析构函数顺序 C虚基类成员可见性 程序一如下&#xff1a; #include<iostream> using namespace std; class A { public:A(int a) :x(a) { cout << "A const…
阅读更多...
C++小型公司管理系统

C++小型公司管理系统

项目要求&#xff1a; 编写一个程序实现小型公司的人员信息管理系统。该公司雇员&#xff08;employee&#xff09;包括经理&#xff08;manager&#xff09;&#xff0c;技术人员&#xff08;technician&#xff09;、销售员&#xff08;salesman&#xff09;和销售部经理&…
阅读更多...
Linux网络编程“惊群”问题总结

Linux网络编程“惊群”问题总结

http://www.cnblogs.com/Anker/p/7071849.html 1、前言 我从事Linux系统下网络开发将近4年了&#xff0c;经常还是遇到一些问题&#xff0c;只是知其然而不知其所以然&#xff0c;有时候和其他人交流&#xff0c;搞得非常尴尬。如今计算机都是多核了&#xff0c;网络编程框架也…
阅读更多...
yfan.qiu linux硬链接与软链接

yfan.qiu linux硬链接与软链接

http://www.cnblogs.com/yfanqiu/archive/2012/06/11/2545556.html Linux 系统中有软链接和硬链接两种特殊的“文件”。 软链接可以看作是Windows中的快捷方式&#xff0c;可以让你快速链接到目标档案或目录。 硬链接则透过文件系统的inode来产生新档名&#xff0c;而不是产生…
阅读更多...
Linux C++线程池实例

Linux C++线程池实例

http://www.cnblogs.com/danxi/p/6636095.html 想做一个多线程服务器测试程序&#xff0c;因此参考了github的一些实例&#xff0c;然后自己动手写了类似的代码来加深理解。 目前了解的线程池实现有2种思路&#xff1a; 第一种&#xff1a; 主进程创建一定数量的线程&#xff0…
阅读更多...
Java编写简单的自定义异常类

Java编写简单的自定义异常类

除了系统中自己带的异常&#xff0c;我们也可以自己写一些简单的异常类来帮助我们处理问题。 所有的异常命名都是以Exception结尾&#xff0c;并且都是Exception的子类。 假设我们要编写一个人类的类&#xff0c;为了判断年龄的输入是否合法&#xff0c;我们编写了一个名为Il…
阅读更多...
【Java学习笔记九】多线程

【Java学习笔记九】多线程

程序&#xff1a;计算机指令的集合&#xff0c;它以文件的形式存储在磁盘上&#xff0c;是应用程序执行的蓝本。 进程&#xff1a;是一个程序在其自身的地址空间中的一次执行活动。进程是资源申请、调度和独立运行的单位&#xff0c;因此&#xff0c;它使用系统中的运行资源。而…
阅读更多...
【C++学习笔记四】运算符重载

【C++学习笔记四】运算符重载

当调用一个重载函数和重载运算符时&#xff0c;编译器通过把您所使用的参数类型和定义中的参数类型相比较&#xff0c;巨鼎选用最合适的定义。&#xff08;重载决策&#xff09; 重载运算符时带有特殊名称的函数&#xff0c;函数名是由关键字operator和其后要重载的运算符符号…
阅读更多...
C++（纯）虚函数重写时访问权限更改问题

C++（纯）虚函数重写时访问权限更改问题

我们知道在Java中是自动实现多态的&#xff0c;Java中规定重写的方法的访问权限不能缩小。那么在C中我们实现多态的时候是否可以更改&#xff08;缩小&#xff09;访问权限呢&#xff1f; 经过测试&#xff0c;得到的答案如下&#xff1a;如果用基类指针指向派生类对象实现多态…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023