基于epoll的简单的http服务器

http://blog.csdn.net/fangjian1204/article/details/34415651

http服务器已经可以处理并发连接，支持多个客户端并发访问，每个连接可以持续读写数据，当然，这只是一个简单的学习例子，还有很多bug，发表出来只是希望大家可以互相学习，我也在不断的改进，希望大家有什么意见可以多多指点，谢谢


server.h

[cpp] view plain copy
  1. /* 
  2.  * server.h 
  3.  * 
  4.  *  Created on: Jun 23, 2014 
  5.  *      Author: fangjian 
  6.  */  
  7.   
  8.   
  9. #ifndef SERVER_H_  
  10. #define SERVER_H_  
  11.   
  12. #include "epoll_event.h"  
  13.   
  14. struct web_event_t;  
  15. struct web_connection_t  
  16. {  
  17.     int fd;  
  18.   
  19.     int state;//当前处理到哪个阶段  
  20.     struct web_event_t* read_event;  
  21.     struct web_event_t* write_event;  
  22.     char* querybuf;  
  23.     int query_start_index;//请求数据的当前指针  
  24.     int query_end_index;//请求数据的下一个位置  
  25.     int query_remain_len;//可用空间  
  26.   
  27.     char method[8];  
  28.     char uri[128];  
  29.     char version[16];  
  30.     char host[128];  
  31.     char accept[128];  
  32.     char conn[20];  
  33. };  
  34.   
  35. struct server  
  36. {  
  37.     int epollfd;  
  38. };  
  39.   
  40. void web_epoll_ctl(int epollfd,int ctl,int fd,int flag);  
  41. int setnonblocking(int fd);  
  42. void initConnection(web_connection_t* &conn);  
  43. void web_accept(struct web_connection_t* conn);  
  44. void read_request( struct web_connection_t* conn );  
  45. void process_request_line(struct web_connection_t* conn);  
  46. void process_head(struct web_connection_t* conn);  
  47. void process_body(struct web_connection_t* conn);  
  48. void send_response(struct web_connection_t* conn);  
  49. void try_to_enlarge_buffer(struct web_connection_t& conn);  
  50. void empty_event_handler(struct web_connection_t* conn);  
  51. void close_conn( struct web_connection_t* conn );  
  52.   
  53. #endif /* SERVER_H_ */  

server.cpp

[cpp] view plain copy
  1. /* 
  2.  * server.cpp 
  3.  * 
  4.  *  Created on: Jun 23, 2014 
  5.  *      Author: fangjian 
  6.  */  
  7.   
  8. #include "server.h"  
  9. #include "epoll_event.h"  
  10.   
  11. #include <stdio.h>  
  12. #include <netinet/in.h>  
  13. #include <arpa/inet.h>  
  14. #include <string.h>  
  15. #include <stdlib.h>  
  16. #include <fcntl.h>  
  17. #include<signal.h>  
  18. #include <sys/socket.h>  
  19. #include <sys/epoll.h>  
  20. #include <sys/stat.h>  
  21. #include <sys/sendfile.h>  
  22. #include <iostream>  
  23. using namespace std;  
  24.   
  25. int main(int argc,char* argv[])  
  26. {  
  27.     const char* ip = "127.0.0.1";  
  28.     int port =  8083;  
  29.   
  30.     signal(SIGPIPE,SIG_IGN);//原因：http://blog.sina.com.cn/s/blog_502d765f0100kopn.html  
  31.   
  32.     int listenfd = socket(AF_INET,SOCK_STREAM,0);  
  33.     struct sockaddr_in address;  
  34.     bzero(&address,sizeof(address));  
  35.     address.sin_family = AF_INET;  
  36.     inet_pton(AF_INET,ip,&address.sin_addr);  
  37.     address.sin_port = htons(port);  
  38.     bind(listenfd,(struct sockaddr*)&address,sizeof(address));  
  39.     listen(listenfd,50);  
  40.   
  41.     web_connection_t* conn = NULL;  
  42.     epoll_init_event(conn);  
  43.     initConnection(conn);//创建一个用于接受连接的结构体  
  44.     if(conn == NULL){printf("---创建监听结构体失败---\n");return -1;};//创建监听结构体  
  45.   
  46.     conn->fd = listenfd;  
  47.     conn->read_event->handler = web_accept;  
  48.     epoll_add_event(conn,EPOLLIN | EPOLLERR);  
  49.   
  50.     setnonblocking(listenfd);  
  51.   
  52.     fork();  
  53.   
  54.     ngx_epoll_process_events();//进入事件循环，等待事件到达  
  55. }  
  56. void initConnection(web_connection_t* &conn)  
  57. {  
  58.     conn = (web_connection_t*)malloc(sizeof(web_connection_t));  
  59.     conn->read_event = (web_event_t*)malloc(sizeof(web_event_t));  
  60.     conn->write_event = (web_event_t*)malloc(sizeof(web_event_t));  
  61.     conn->state = ACCEPT;  
  62.   
  63.     conn->querybuf = (char*)malloc(QUERY_INIT_LEN);  
  64.     if(!conn->querybuf)  
  65.     {  
  66.         printf(" malloc error\n");  
  67.         return;  
  68.     }  
  69.     conn->query_start_index = 0;  
  70.     conn->query_end_index = 0;  
  71.     conn->query_remain_len = QUERY_INIT_LEN;  
  72. }  
  73.   
  74. int setnonblocking(int fd)  
  75. {  
  76.     int old_option = fcntl(fd,F_GETFL);  
  77.     int new_option = old_option | O_NONBLOCK;  
  78.     fcntl(fd,F_SETFL,new_option);  
  79.     return old_option;  
  80. }  
  81.   
  82. void web_accept(web_connection_t* conn)  
  83. {  
  84.     printf("-----------accept-------\n");  
  85.     struct sockaddr * client_address;  
  86.     socklen_t client_addrlength = sizeof(client_address);  
  87.     int connfd = accept(conn->fd,(struct sockaddr*)&(client_address),&client_addrlength);  
  88.     if(connfd == -1)  
  89.     {  
  90.         printf("accept error\n");  
  91.         return;  
  92.     }  
  93.     web_connection_t* new_conn = NULL;  
  94.     initConnection(new_conn);//创建一个新的连接结构体  
  95.     if(new_conn == NULL){printf("---创建连接结构体失败---\n");return;};  
  96.   
  97.     new_conn->fd = connfd;  
  98.     new_conn->state = READ;  
  99.     new_conn->read_event->handler = read_request;  
  100.     epoll_add_event(new_conn,EPOLLIN | EPOLLERR);  
  101.   
  102.     setnonblocking(connfd);  
  103. }  
  104. void read_request( struct web_connection_t* conn )  
  105. {  
  106.     printf("-----------read_begin-------\n");  
  107.   
  108.     int len,fd = conn->fd;  
  109.     while(true)  
  110.     {  
  111.         /* 尝试增加缓冲区空间 */  
  112.         try_to_enlarge_buffer(*conn);  
  113.         len= recv(fd,conn->querybuf + conn->query_end_index,conn->query_remain_len,0);  
  114.         if(len < 0)  
  115.         {  
  116.             printf("----数据读取完毕-----\n");  
  117.             break;//表示当前数据读取完毕，不是出错  
  118.         }  
  119.         else if(len > 0)  
  120.         {  
  121.             conn->query_end_index += len;  
  122.             conn->query_remain_len-= len;  
  123.         }  
  124.         else if(len == 0)  
  125.         {  
  126.             printf("----连接关闭-----\n");  
  127.             epoll_del_event(conn);  
  128.             close_conn(conn );  
  129.             return ;  
  130.         }  
  131.     }  
  132.     cout << "-----客户端的内容是 " << endl;  
  133.   
  134.     cout << conn->querybuf << endl;  
  135.   
  136.     process_request_line(conn);  
  137.   
  138.     return ;  
  139. }  
  140. void process_request_line(struct web_connection_t* conn)  
  141. {  
  142.     int len;  
  143.     char* ptr = strpbrk(conn->querybuf + conn->query_start_index," \t");  
  144.     if( !ptr)  
  145.     {  
  146.         printf("请求行解析失败\n");  
  147.         return;  
  148.     }  
  149.     len = ptr - conn->querybuf - conn->query_start_index;  
  150.     strncpy(conn->method,conn->querybuf + conn->query_start_index,len);  
  151.     cout <<"metnod="<<conn->method<<endl;  
  152.   
  153.     conn->query_start_index += (len+1);  
  154.     ptr = strpbrk(conn->querybuf + conn->query_start_index," \t");  
  155.     if( !ptr)  
  156.     {  
  157.         printf("请求行解析失败\n");  
  158.         return;  
  159.     }  
  160.     len = ptr - conn->querybuf - conn->query_start_index;  
  161.     strncpy(conn->uri,conn->querybuf + conn->query_start_index,len);  
  162.     cout << "uri="<<conn->uri<<endl;  
  163.   
  164.     conn->query_start_index += (len+1);  
  165.     ptr = strpbrk(conn->querybuf,"\n");//先是回车\r,再是换行\n  
  166.     if(!ptr)  
  167.     {  
  168.         printf("请求行解析失败\n");  
  169.         return;  
  170.     }  
  171.     len = ptr - conn->querybuf - conn->query_start_index;  
  172.     strncpy(conn->version,conn->querybuf + conn->query_start_index,len);  
  173.     cout << "version="<<conn->version<<endl;  
  174.     conn->query_start_index += (len+1);  
  175.   
  176.     cout <<"-----请求行解析完毕----------"<<endl;  
  177.   
  178.     process_head(conn);  
  179. }  
  180.   
  181. void process_head(struct web_connection_t* conn)  
  182. {  
  183.     cout << "-------开始解析首部------" << endl;  
  184.   
  185.     char* end_line;  
  186.     int len;  
  187.   
  188.     while(true)  
  189.     {  
  190.         end_line = strpbrk(conn->querybuf + conn->query_start_index,"\n");  
  191.         len = end_line - conn->querybuf - conn->query_start_index;  
  192.         if(len == 1)  
  193.         {  
  194.             printf("解析完毕\n");  
  195.             conn->query_start_index += (len +1);  
  196.             cout << conn->querybuf + conn->query_start_index << endl;  
  197.             break;  
  198.         }  
  199.         else  
  200.         {  
  201.             if(strncasecmp(conn->querybuf+conn->query_start_index,"Host:",5) == 0)  
  202.             {  
  203.                 strncpy(conn->host,conn->querybuf+conn->query_start_index + 6,len-6);  
  204.                 cout << "host="<<conn->host<<endl;  
  205.             }  
  206.             else if(strncasecmp(conn->querybuf+conn->query_start_index,"Accept:",7) == 0)  
  207.             {  
  208.                 strncpy(conn->accept,conn->querybuf+conn->query_start_index + 8,len-8);  
  209.                 cout <<"accept="<<conn->accept <<endl;  
  210.             }  
  211.             else if(strncasecmp(conn->querybuf+conn->query_start_index,"Connection:",11) == 0)  
  212.             {  
  213.                 strncpy(conn->conn,conn->querybuf+conn->query_start_index + 12,len-12);  
  214.                 cout <<"connection="<<conn->conn <<endl;  
  215.             }  
  216.             else  
  217.             {  
  218.             }  
  219.             conn->query_start_index += (len +1);  
  220.         }  
  221.     }  
  222.     process_body(conn);  
  223.     printf("----首部解析完毕----------\n");  
  224. }  
  225. void process_body(struct web_connection_t* conn)  
  226. {  
  227.     if(conn->query_start_index == conn->query_end_index)  
  228.     {  
  229.         printf("---包体为空----\n");  
  230.     }  
  231.     else  
  232.     {  
  233.         printf("---丢体包体-----\n");  
  234.     }  
  235.     conn->query_start_index = conn->query_end_index = 0;  
  236.   
  237.     conn->state = SEND_DATA;  
  238.     conn->write_event->handler = send_response;  
  239.     conn->read_event->handler = empty_event_handler;//读事件回调函数设置为空  
  240.     epoll_mod_event(conn,EPOLLOUT | EPOLLERR);  
  241. }  
  242. void send_response(struct web_connection_t* conn)  
  243. {  
  244.     char path[128] = "http";//根目录下的文件夹  
  245.     int len = strlen(conn->uri);  
  246.     memcpy(path+4,conn->uri,len);  
  247.     len += 4;  
  248.     path[len] = '\0';//很重要  
  249.   
  250.     int filefd = open(path,O_RDONLY);  
  251.     if(filefd < 0)  
  252.     {  
  253.         cout << "无法打开该文件" <<endl;  
  254.         return ;  
  255.     }  
  256.     struct stat stat_buf;  
  257.     fstat(filefd,&stat_buf);  
  258.     sendfile(conn->fd,filefd,NULL,stat_buf.st_size);  
  259.     close(filefd);  
  260.   
  261.     //close(conn->fd);//如果不关闭该连接socket，则浏览器一直在加载，如何解决，保持keep-alive?  
  262.   
  263.     conn->state = READ;  
  264.     conn->read_event->handler = read_request;  
  265.     epoll_mod_event(conn,EPOLLIN | EPOLLERR);  
  266.   
  267.     //sleep(2);  
  268. }  
  269.   
  270. void try_to_enlarge_buffer(struct web_connection_t& conn)  
  271. {  
  272.     if(conn.query_remain_len  < REMAIN_BUFFER)  
  273.     {  
  274.         int new_size = strlen(conn.querybuf) + QUERY_INIT_LEN;  
  275.         conn.querybuf = (char*)realloc(conn.querybuf,new_size);  
  276.         conn.query_remain_len  = new_size - conn.query_end_index;  
  277.     }  
  278. }  
  279. void empty_event_handler(struct web_connection_t* conn)  
  280. {  
  281.   
  282. }  
  283. //关闭一个连接  
  284. void close_conn( struct web_connection_t* conn )  
  285. {  
  286.     static int count = 0;  
  287.     count ++;  
  288.     printf("关闭第%d个连接\n",count);  
  289.   
  290.     close( conn->fd);  
  291.     free(conn->querybuf);  
  292.     free(conn->read_event);  
  293.     free(conn->write_event);  
  294.     free(conn);  
  295. }  

epoll_event.h

[cpp] view plain copy
  1. /* 
  2.  * event.h 
  3.  * 
  4.  *  Created on: Jun 25, 2014 
  5.  *      Author: fangjian 
  6.  */  
  7.   
  8. #ifndef EVENT_H_  
  9. #define EVENT_H_  
  10.   
  11. #include <netinet/in.h>  
  12. #include "server.h"  
  13. #define MAX_EVENT_NUMBER 10000  
  14. #define QUERY_INIT_LEN  1024  
  15. #define REMAIN_BUFFER  512  
  16.   
  17. /* 以下是处理机的状态 */  
  18. #define ACCEPT 1  
  19. #define READ 2  
  20. #define QUERY_LINE 4  
  21. #define QUERY_HEAD 8  
  22. #define QUERY_BODY 16  
  23. #define SEND_DATA 32  
  24.   
  25. struct web_connection_t;  
  26.   
  27. typedef void (*event_handler_pt)(web_connection_t* conn);  
  28.   
  29. //每一个事件都由web_event_t结构体来表示  
  30. struct web_event_t  
  31. {  
  32.     /*为1时表示事件是可写的，通常情况下，它表示对应的TCP连接目前状态是可写的，也就是连接处于可以发送网络包的状态*/  
  33.     unsigned         write:1;  
  34.     /*为1时表示此事件可以建立新的连接,通常情况下，在ngx_cycle_t中的listening动态数组中，每一个监听对象ngx_listening_t对应的读事件中 
  35.     的accept标志位才会是1*/  
  36.     unsigned         accept:1;  
  37.     //为1时表示当前事件是活跃的，这个状态对应着事件驱动模块处理方式的不同，例如：在添加事件、删除事件和处理事件时，该标志位的不同都会对应着不同的处理方式  
  38.     unsigned         active:1;  
  39.     unsigned         oneshot:1;  
  40.     unsigned         eof:1;//为1时表示当前处理的字符流已经结束  
  41.     unsigned         error:1;//为1时表示事件处理过程中出现了错误  
  42.   
  43.     event_handler_pt  handler;//事件处理方法，每个消费者模块都是重新实现它  
  44.     unsigned         closed:1;//为1时表示当前事件已经关闭  
  45. };  
  46.   
  47. void epoll_init_event(web_connection_t* &conn);  
  48. void epoll_add_event(web_connection_t* conn,int flag);  
  49. void epoll_mod_event(web_connection_t* conn,int flag);  
  50. void epoll_del_event(web_connection_t* conn);  
  51. int ngx_epoll_process_events();  
  52. #endif /* EVENT_H_ */  

epoll_event.cpp

[cpp] view plain copy
  1. /* 
  2.  * event.cpp 
  3.  * 
  4.  *  Created on: Jun 25, 2014 
  5.  *      Author: fangjian 
  6.  */  
  7.   
  8. #include "epoll_event.h"  
  9. #include <sys/epoll.h>  
  10. #include <unistd.h>  
  11. #include <stdio.h>  
  12. #include <stdlib.h>  
  13.   
  14. static int  ep = -1;//epoll对象的描述符,每个进程只有一个  
  15.   
  16. void epoll_init_event(web_connection_t* &conn)  
  17. {  
  18.     ep = epoll_create(1024);  
  19. }  
  20.   
  21. /* 添加事件,conn已经设置好回调函数和fd了 */  
  22. void epoll_add_event(web_connection_t* conn,int flag)  
  23. {  
  24.     epoll_event ee;  
  25.     int fd = conn->fd;  
  26.     ee.data.ptr = (void*)conn;  
  27.     ee.events = flag;  
  28.     epoll_ctl(ep,EPOLL_CTL_ADD,fd,&ee);  
  29. }  
  30.   
  31. /* 修改事件,event已经设置好回调函数和fd了 */  
  32. void epoll_mod_event(web_connection_t* conn,int flag)  
  33. {  
  34.     epoll_event ee;  
  35.     int fd = conn->fd;  
  36.     ee.data.ptr = (void*)conn;  
  37.     ee.events = flag;  
  38.     epoll_ctl(ep,EPOLL_CTL_MOD,fd,&ee);  
  39. }  
  40.   
  41. //删除该描述符上的所有事件，若想只删除读事件或写事件，则把相应的事件设置为空函数  
  42. void epoll_del_event(web_connection_t* conn)  
  43. {  
  44.     epoll_ctl( ep, EPOLL_CTL_DEL, conn->fd, 0 );//删除事件最后一个参数为0  
  45. }  
  46. //事件循环函数  
  47. int ngx_epoll_process_events()  
  48. {  
  49.     epoll_event event_list[MAX_EVENT_NUMBER];  
  50.     while(true)  
  51.     {  
  52.         int number = epoll_wait(ep,event_list,MAX_EVENT_NUMBER,-1);  
  53.   
  54.         printf("number=%d\n",number);  
  55.         printf("当前进程ID为： %d \n",getpid());  
  56.   
  57.         int i;  
  58.         for(i = 0;i < number;i++)  
  59.         {  
  60.             web_connection_t* conn = (web_connection_t*)(event_list[i].data.ptr);  
  61.             int socket = conn->fd;//当前触发的fd  
  62.             //读事件  
  63.             if ( event_list[i].events & EPOLLIN )  
  64.             {  
  65.                 conn->read_event->handler(conn);  
  66.             }  
  67.             //写事件  
  68.             else if( event_list[i].events & EPOLLOUT )  
  69.             {  
  70.                 conn->write_event->handler(conn);  
  71.             }  
  72.             else if( event_list[i].events & EPOLLERR )  
  73.             {  
  74.   
  75.             }  
  76.         }  
  77.     }  
  78.     return 0;  
  79. }  

使用方法：

服务器使用方法：直接运行即可
客户端使用方法：编译客户端代码，然后 ./client 127.0.0.1 8083 5（最后一个代表客户端进程数）
本程序在linux平台下测试成功

免费代码下载地址：http://download.csdn.net/detail/fangjian1204/7575477


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

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

相关文章

C++单例模式简单实现

C++单例模式简单实现

有时候我们需要某个类只能被实例化一次&#xff0c;并且其他类都可以访问到这个类&#xff0c;就需要这种设计模式。 例如我们想要做个资源管理器&#xff0c;显然这个管理器只能有一个。 这种模式有很多实现方式&#xff0c;这里介绍最简单的一种&#xff0c;想要了解更多可…
阅读更多...
Linux C++ 实现线程池

Linux C++ 实现线程池

http://blog.csdn.net/qq_25425023/article/details/53914609 线程池中的线程&#xff0c;在任务队列为空的时候&#xff0c;等待任务的到来&#xff0c;任务队列中有任务时&#xff0c;则依次获取任务来执行&#xff0c;任务队列需要同步。 Linux线程同步有多种方法&#xff…
阅读更多...
C++制表符

C++制表符

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

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

参考博客&#xff1a;传送门1 当类中含有对象成员时&#xff1a; 类的构造函数要包含对成员对象的初始化&#xff0c;如果构造函数的成员初始化列表没有包含对成员对象的初始化&#xff0c;系统会自动调用成员对象的无参构造函数。顺序上&#xff1a;先调用成员对象的构造函数…
阅读更多...
c，c++中字符串处理函数strtok，strstr，strchr，strsub

c，c++中字符串处理函数strtok，strstr，strchr，strsub

http://blog.csdn.net/wangqing_12345/article/details/51760220 1&#xff0c;字符串切割函数 函数原型&#xff1a;char *strtok(char *s, char *delim); 函数功能&#xff1a;把字符串s按照字符串delim进行分割&#xff0c;然后返回分割的结果。 函数使用说&#xff1a; 1…
阅读更多...
C++虚基类成员可见性

C++虚基类成员可见性

详见《CPrimer》[第五版]719页 如果继承路径上没有和虚基类成员重名的成员&#xff0c;则不存在二义性&#xff0c;因为我们仅能访问到虚基类成员。 当访问仅有一条继承路径上含有和虚基类成员重名的成员&#xff0c;也不存在二义性。派生类的成员的优先级比基类的成员高&…
阅读更多...
链表逆序的原理及实例

链表逆序的原理及实例

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…
阅读更多...
strtok函数及其实现

strtok函数及其实现

头文件&#xff1a;#include <string.h> 定义函数&#xff1a;char * strtok(char *s, const char *delim); 函数说明&#xff1a;strtok()用来将字符串分割成一个个片段。参数s 指向欲分割的字符串&#xff0c;参数delim 则为分割字符串&#xff0c;当 strtok()在参数s …
阅读更多...
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;网络编程框架也…
阅读更多...
【Java学习笔记六】常用数据对象之String

【Java学习笔记六】常用数据对象之String

字符串 在Java中系统定义了两种类型的字符串类&#xff1a;String和StringBuffer String类对象的值和长度都不能改变&#xff0c;称为常量字符串类&#xff0c;其中每个值称为常量字符串。 StringBuffer类对象的值和长度都可以改变&#xff0c;称为变量字符串类&#xff0c;其…
阅读更多...
【Java学习笔记七】常用数据对象之数组

【Java学习笔记七】常用数据对象之数组

同一般的对象创建和定义一样&#xff0c;数组的定义和创建可以分开进行也可以合并一起进行。 一维数组定义格式&#xff1a; <元素类型>[] <数组名>;//[]也可以放在数组名的后面一维数组创建格式&#xff1a; new <元素类型>[<元素个数>];执行new运…
阅读更多...
yfan.qiu linux硬链接与软链接

yfan.qiu linux硬链接与软链接

http://www.cnblogs.com/yfanqiu/archive/2012/06/11/2545556.html Linux 系统中有软链接和硬链接两种特殊的“文件”。 软链接可以看作是Windows中的快捷方式&#xff0c;可以让你快速链接到目标档案或目录。 硬链接则透过文件系统的inode来产生新档名&#xff0c;而不是产生…
阅读更多...
【Java学习笔记八】包装类和vector

【Java学习笔记八】包装类和vector

包装类 在Java语言中&#xff0c;每一种基本的数据类型都有相应的对象类型&#xff0c;称为他们基本类型的包装类&#xff08;包裹类&#xff09;。 字节byte&#xff1a;Byte、短整数型short&#xff1a;Short 标准整数型int&#xff1a;Integer、长整数型long&#xff1a;Lo…
阅读更多...
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…
阅读更多...
shared_ptr简介以及常见问题

shared_ptr简介以及常见问题

http://blog.csdn.net/stelalala/article/details/19993425 本文中的shared_ptr以vs2010中的std::tr1::shared_ptr作为研究对象。可能和boost中的有些许差异&#xff0c;特此说明。 基本功能 shared_ptr提供了一个管理内存的简单有效的方法。shared_ptr能在以下方面给开发提供便…
阅读更多...
【Java学习笔记九】多线程

【Java学习笔记九】多线程

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

【C++11新特性】 C++11智能指针之weak_ptr

http://blog.csdn.net/xiejingfa/article/details/50772571 原创作品&#xff0c;转载请标明&#xff1a;http://blog.csdn.net/Xiejingfa/article/details/50772571 如题&#xff0c;我们今天要讲的是C11引入的三种智能指针中的最后一个&#xff1a;weak_ptr。在学习weak_ptr之…
阅读更多...
最新文章

Copyright @ 2022~2023