C++博客-
一年十二月谁主春秋
-随笔分类-Opensrc

一种扩展nginx支持windows服务的方法

春秋十二月 — Wed, 20 Nov 2019 11:45:00 GMT

描述
nginx是一款著名的高性能开源Web与反向代理服务器，支持windows和linux操作系统，因为在windows系统上还不支持SCM（服务控制管理），所以只能以控制台方式运行，但这样并不是在后台运行，也不能在系统登录前启动。针对这些问题，本方法通过改进源码，使nginx良好地支持了SCM，方便了部署运行

特点
最大地复用了nginx源码；支持SCM，并兼容控制台运行方式；统一处理异常退出而报告服务停止

实现

变换原主函数

将原来的main函数更名为ngx_main，并增加第3个参数is_scm来标识运行方式，非0表示服务方式，0表示控制台方式，流程如下

图上红色部分为插入的逻辑，其它部分为nginx原来的逻辑。由于服务初始化须将错误记录在log（日志）中，所以应在初始化log模块后调用

增加主函数

这个主函数也就是程序入口main，可被控制台或SCM调用，当被SCM调用时，注册服务以及启动服务控制调度程序，流程如下

如果以命令行启动nginx 也就是master进程（管理进程），或nginx产生worker进程（工作进程）时，那么以控制台方式调用main，进而以is_scm为0调用ngx_main，当ngx_main返回时，就表示master或worker进程退出了

服务主函数

      由SCM生成的一个逻辑线程调用，流程如下

    这里的逻辑线程代替了nginx的master进程，到这里就表明已经以SCM方式运行了，所以以is_scm为1调用ngx_main，当ngx_main返回时，就表明master进程退出了，应该更新服务状态为已停止，然后返回表明当前服务结束了

   服务初始化

    由ngx_main调用，见变换原主函数流程图，流程如下

    由于在nginx实现中，有多处出现异常错误而直接退出，因此首先注册了进程退出处理器，在其内报告服务状态为已停止，这样只要当进程退出了，在SCM上就能看到已停止的状态了

服务控制处理器

由SCM的主线程调用，流程如下

调用关系
下图左边为master进程调用模块与函数，右边为worker进程调用模块与函数，委托主函数是ngx_main

春秋十二月 2019-11-20 19:45 发表评论

一种统计云查询黑文件的方法及系统

春秋十二月 — Thu, 25 Aug 2016 03:10:00 GMT

描述
云查杀平台以nginx作为反向代理服务器，作为安全终端与云查询服务的桥梁。当安全终端需要查询黑文件时，HTTP请求及其响应都会经过nginx，为了获取并统计一天24小时查询的黑文件数量，就得先截获经过nginx的HTTP响应，再做数据分析。截获HTTP数据流有多种方法，为了简单高效，这里使用了挂接HTTP过滤模块的方法，另外为了不影响nginx本身的IO处理，将HTTP响应实体发送到另一个进程即统计服务，由统计服务来接收并分析HTTP响应，架构如下图

   统计服务由1个接收线程和1个存储线程构成，其中接收线程负责接收从nginx过滤模块发来的HTTP响应实体，解析它并提取黑文件MD5，加入共享环形队列；而存储线程从共享环形队列移出黑文件MD5，插入到临时内存映射文件，于每天定时同步到磁盘文件。

特点
   这种架构减少了nginx IO延迟，保证了nginx的稳定高效运行，从而不影响用户的业务运行；本地连接为非阻塞的，支持了统计服务的独立运行与升级。

实现
   nginx过滤模块
      该流程运行在nginx工作进程。

      由于nginx采用了异步IO机制，因此仅当截获到HTTP响应实体也就是有数据经过时，才有后面的操作；若没有数据，则什么也不用做。这里每次发送前先判断是否连接了统计服务，是为了支持统计服务的独立运行与升级，换句话说，不管统计服务是否运行或崩溃，都不影响nginx的运行。

统计服务
   接收线程
      这里的接收线程也就是主线程。

存储线程
存储线程为另一个工作线程。

同步文件定时器的时间间隔要比新建文件定时器的短，由于定时器到期的事件处理是一种异步执行流，所以将它们当做并行，与“从q头移出黑文件MD5”操作画在了同一水平方向。

春秋十二月 2016-08-25 11:10 发表评论

nginx iocp（3）：scm服务控制

春秋十二月 — Tue, 12 Jul 2016 07:31:00 GMT

摘要: 为了使nginx支持windows服务，本文阐述以下主要的改进实现。ngx_main函数为了在SCM服务中复用main函数的逻辑，将其重命名为ngx_main，并添加第3个参数is_scm以兼容控制台运行方式，声明在core/nginx.h中。 Code highligh... 阅读全文

春秋十二月 2016-07-12 15:31 发表评论

nginx iocp（2）：udp异步接收

春秋十二月 — Thu, 25 Jun 2015 09:01:00 GMT

nginx的域名解析器使用已连接udp（收发前先调用ngx_udp_connect）发送dns查询、接收dns响应，如上篇tcp异步连接所讲，iocp需要先投递udp的接收操作，才能引发接收完成的事件，因此要对域名解析器和udp异步接收作些改进。

发送后投递
dns查询由ngx_resolver_send_query函数实现，定义在core/ngx_resolver.c中。

1static ngx_int_t ngx_resolver_send_query(ngx_resolver_t *r, ngx_resolver_node_t *rn)
2{
3
4     if (rn->naddrs == (u_short) -1) {
5        n = ngx_send(uc->connection, rn->query, rn->qlen);
6
7  }
8
9#if (NGX_HAVE_INET6)
10  if (rn->query6 && rn->naddrs6 == (u_short) -1) {
11      n = ngx_send(uc->connection, rn->query6, rn->qlen);
12
13  }
14#endif
15
16#if (NGX_WIN32)
17    if (ngx_event_flags & NGX_USE_IOCP_EVENT){
18        uc->connection->read->ready = 1;
19        ngx_resolver_read_response(uc->connection->read);
20}
21#endif
22
23  return NGX_OK;
24}

当nginx用于代理连接上游服务器前，要先解析域名，首次调用链为：ngx_http_upstream_init_request->ngx_resolver_name->ngx_resolver_name_locked->ngx_resolver_send_query；若5s（单次超时）后还没收到dns响应，则再发送1次查询，调用链为：ngx_resolver_resend_handler->ngx_resolver_resend->ngx_resolver_send_query，如此反复，直到收到响应或30s（默认总超时）后不再发送查询。它调用ngx_send发送dns查询，16行~21行代码为笔者添加，ngx_resolver_read_response函数用于接收并分析dns响应报文，它会调用到下面的ngx_udp_overlapped_wsarecv函数。

异步接收
由ngx_udp_overlapped_wsarecv函数实现，定义在os/win32/ngx_udp_wsarecv.c中。

1ssize_t ngx_udp_overlapped_wsarecv(ngx_connection_t *c, u_char *buf, size_t size)
2{
3   int             flags, rc;
4    WSABUF          wsabuf;
5    ngx_err_t       err;
6    ngx_event_t    *rev;
7    WSAOVERLAPPED  *ovlp;
8    u_long             bytes;
9
10    rev = c->read;
11
12    if (!rev->ready) {
13      ngx_log_error(NGX_LOG_ALERT, c->log, 0, "ngx_udp_overlapped_wsarecv second wsa post");
14      return NGX_AGAIN;
15  }
16
17  if (rev->complete) {
18   if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
19       if (rev->ovlp.error && rev->ovlp.error != ERROR_MORE_DATA) {
20           ngx_connection_error(c, rev->ovlp.error, "ngx_udp_overlapped_wsarecv() failed");
21           return NGX_ERROR;
22       }
23   }
24
25   rev->complete = 0;
26  }
27
28    ovlp = NULL;
29    wsabuf.buf = (CHAR *) buf;
30    wsabuf.len = (ULONG) size;
31    flags = 0;
32
33retry:
34    rc = WSARecv(c->fd, &wsabuf, 1, (DWORD*)&bytes, (LPDWORD)&flags, ovlp, NULL);
35
36    if (rc == -1) {
37         rev->ready = 0;
38         err = ngx_socket_errno;
39
40       if (err == WSA_IO_PENDING) {
41             return NGX_AGAIN;
42         }
43
44       if (err == WSAEWOULDBLOCK) {
45           if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
46                 rev->ovlp.type = NGX_IOCP_IO;
47                 ovlp = (WSAOVERLAPPED *)&rev->ovlp;
48                 ngx_memzero(ovlp, sizeof(WSAOVERLAPPED));
49
50                 wsabuf.buf = NULL;
51                 wsabuf.len = 0;
52                 flags = MSG_PEEK;
53
54                goto retry;
55            }
56
57            return NGX_AGAIN;
58        }
59
60        ngx_connection_error(c, err, "ngx_udp_overlapped_wsarecv() failed");
61        rev->error = 1;
62
63        return NGX_ERROR;
64    }
65
66    if ((ngx_event_flags & NGX_USE_IOCP_EVENT) && ovlp) {
67        rev->ready = 0;
68        return NGX_AGAIN;
69    }
70
71    return bytes;
72}

先以非阻塞方式接收，若发生WSAWOULDBLOCK错误，则使用MSG_PEEK标志投递一个0字节的重叠接收操作，当dns响应返回时发生完成事件，会再次进入ngx_resolver_read_response而调用到该函数，此时rev->complete为1，rev->ovlp.error为ERROR_MORE_DATA（GetQueuedCompletionStatus返回的错误），由于使用了MSG_PEEK，因此数据还在接收缓冲区中，要忽略ERROR_MORE_DATA而继续接收，这时就能成功了。不管WSARecv返回WSA_IO_PENDING错误还是成功，iocp都会得到完成通知，所以这里当重叠操作投递成功时，返回NGX_AGAIN，便于在回调内统一处理。

春秋十二月 2015-06-25 17:01 发表评论

nginx iocp（1）：tcp异步连接

春秋十二月 — Wed, 24 Jun 2015 09:02:00 GMT

   iocp是Windows NT操作系统的一种高效IO模型，对应于Linux中的epoll和FreeBSD中的kqueue，nginx对ske(select、kqueue和epoll的首写字母组合)的支持很好，但截止到1.6.2版本，还不支持iocp。由于ske都是反应器模式，即先注册IO事件，当IO事件发生（读写通知）时，在其回调内主动调用API来读或写数据；而iocp是前摄器模式，要先投递IO操作，才能引发IO事件（完成通知）的发生，在其回调内数据已被动由操作系统读或写完成。因此，iocp的特点决定了nginx对它的支持与ske有所不同。通过hg clone http://hg.nginx.org/nginx下载的nginx源代码，虽然实现了iocp事件模块、异步接受连接、部分异步读写，但根本不能正常工作，而且不支持异步连接和SCM服务控制，笔者在参考ske模块的实现基础上，改进支持了如下特性：
      1. 异步接受连接时的负载均衡
      2. 正反向代理的异步连接
      3. 异步聚合读写
      4. 域名解析时的UDP异步接收
      5. 异步文件传输
      6. SCM服务控制
   由于2、4、6均为原创，其它几点的思路皆源于ske模块的实现（只是平台API不同），因此本文先阐述异步连接的实现。为了兼容select事件模块，所有iocp相关的代码使用NGX_HAVE_IOCP宏和（或）NGX_USE_IOCP_EVENT标志包围，其中NGX_HAVE_IOCP宏用于条件编译，在WIN32平台下，定义为1；当选择的事件模块为iocp时，全局变量ngx_event_flags才包含NGX_USE_IOCP_EVENT标志。

异步连接对端
   由ngx_event_connect_peer函数（这里省去了与异步连接无关的代码）实现，定义在event/ngx_event_connect.c中，因为connect不支持异步连接事件的完成通知，所以要使用扩展API ConnectEx。

1ngx_int_t ngx_event_connect_peer(ngx_peer_connection_t *pc)
2{
3    int                rc;
4    ngx_int_t          event;
5    ngx_err_t          err;
6    ngx_uint_t         level,family;
7    ngx_socket_t       s;
8    ngx_event_t       *rev, *wev;
9
10    s = ngx_socket(family = pc->sockaddr->sa_family, SOCK_STREAM, 0);
11
12    #if (NGX_HAVE_IOCP)
13    if((pc->local==NULL||pc->local->sockaddr->sa_family != family)
14        && (ngx_event_flags & NGX_USE_IOCP_EVENT)){
15        if(ngx_iocp_set_localaddr(pc->log,family,&pc->local) != NGX_OK)
16            goto failed;
17    }
18    #endif
19
20
21    #if (NGX_HAVE_IOCP)
22    if(ngx_event_flags&NGX_USE_IOCP_EVENT){
23        LPWSAOVERLAPPED   ovlp;
24        ovlp = (LPWSAOVERLAPPED)&wev->ovlp;
25        ngx_memzero(ovlp,sizeof(WSAOVERLAPPED));
26        wev->ovlp.type = NGX_IOCP_CONNECT;
27        rc = ngx_connectex(s,pc->sockaddr,pc->socklen,NULL,0,NULL,ovlp) ? 0 : -1;
28
29    }else
30        rc = connect(s, pc->sockaddr, pc->socklen);
31    #else
32      rc = connect(s, pc->sockaddr, pc->socklen);
33    #endif
34
35    if (rc == -1) {
36        err = ngx_socket_errno;
37        if (err != NGX_EINPROGRESS
38    #if (NGX_WIN32)
39        /* Winsock returns WSAEWOULDBLOCK (NGX_EAGAIN) */
40        && err != NGX_EAGAIN
41    #if (NGX_HAVE_IOCP)
42        && err != WSA_IO_PENDING
43    #endif
44    #endif
45            ){
46
47            ngx_log_error(level, c->log, err, "connect() to %V failed", pc->name);
48            ngx_close_connection(c);
49            pc->connection = NULL;
50
51            return NGX_DECLINED;
52        }
53    }
54
55}

   调用ConnectEx前要先bind本地地址，不然发生WSAEINVAL错误；由于域名解析可能返回IPv6记录，导致创建本地套接字的地址族为AF_INET6，因此bind时需要匹配IPv6地址，不然发生WSAEFAULT错误，导致nginx返回Internal Server Error错误给前端，因此绑定前要调用ngx_iocp_set_localaddr设定正确的本地地址，当且仅当pc->local为空或地址族不匹配时。

本地初始化与设定
   支持IPv6，实现在event/modules/ngx_iocp_module.c。
   地址变量定义如下。

1static struct sockaddr_in  sin;
2#if (NGX_HAVE_INET6)
3static struct sockaddr_in6  sin6;
4#endif
5static ngx_addr_t           local_addr;

sin对应IPv4，sin6对应IPv6，作为bind的套接字本地地址。

sin和sin6在启动iocp事件模块时调用ngx_iocp_init初始化。

1static ngx_int_t ngx_iocp_init(ngx_cycle_t *cycle, ngx_msec_t timer)
2{
3
4  sin.sin_family = AF_INET;
5  sin.sin_port = 0;
6  sin.sin_addr.s_addr = INADDR_ANY;
7
8#if (NGX_HAVE_INET6)
9    sin6.sin6_family = AF_INET6;
10    sin6.sin6_port = 0;
11    sin6.sin6_addr = in6addr_any;
12#endif
13
14  local_addr.name.len = sizeof("INADDR_ANY") - 1;
15  local_addr.name.data = (u_char *)"INADDR_ANY";
16
17}

不论IP地址或端口，都指定为0，表示由系统自动分配出口IP地址和未占用的端口。

本地设定由ngx_iocp_set_localaddr实现。

1ngx_int_t ngx_iocp_set_localaddr(ngx_log_t *log, in_port_t family, ngx_addr_t **local)
2{
3    struct sockaddr *sa;
4    socklen_t len;
5
6    if(AF_INET == family){
7        sa = &sin;
8        len = sizeof(struct sockaddr_in);
9    }
10#if (NGX_HAVE_INET6)
11    else if(AF_INET6 == family){
12        sa = &sin6;
13        len = sizeof(struct sockaddr_in6);
14    }
15#endif
16    else{
17        ngx_log_error(NGX_LOG_ALERT, log, 0, "not supported address family");
18        return NGX_ERROR;
19    }
20
21    local_addr.sockaddr = sa;
22    local_addr.socklen = len;
23    *local = &local_addr;
24
25    return NGX_OK;
26}

对于除IPv4和IPv6外的协议族，则记录一个错误日志。必要时也可扩展支持其它的协议族，例如NetBIOS（对应地址族为AF_NETBIOS），但要看ConnectEx是否支持。

春秋十二月 2015-06-24 17:02 发表评论

面向对象锁框架的设计与实现

春秋十二月 — Sun, 28 Dec 2014 15:38:00 GMT

摘要: 本文描述了一种简单的跨平台锁框架的设计与实现，该框架小巧实用、易于扩展，它的特点如下： ● 实现了线程间互斥锁 ● 实现优化了单线程环境中的空锁和空级别锁 ● 支持编译时或运行时选择锁 ... 阅读全文

春秋十二月 2014-12-28 23:38 发表评论

基于boost asio实现的ssl socket框架

春秋十二月 — Wed, 20 Mar 2013 12:47:00 GMT

摘要: 情景分析现已存在一个可用稳定的异步客户端类http_client_base，该类基于boost asio实现了连接服务器，发送请求，获取响应和解析http数据等操作，该类的大致实现框架如下 Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.C... 阅读全文

春秋十二月 2013-03-20 20:47 发表评论

使用正则表达式解析URL

春秋十二月 — Sun, 27 Nov 2011 09:22:00 GMT

   在开发HTTP相关程序时，经常会碰到从网络链接URL中提取协议名、服务器、路径等目标对象，如果使用C/C++字符串操作函数，那么则显得有点麻烦且代码不易维护，其实关于文本内容的解析工作，都可优先考虑使用正则表达式库来解决处理，C++方面的正则库也有很多种，如atl、pcre、boost。下面就使用boost中的regex来解析URL提取协议名、服务器、路径为目标说明其用法。

协议名
   可有可无，如果有时则后面必跟着://，如果没有，则默认为使用http协议。通常还有其它的协议如https、ssl、ftp、mailto等。因此匹配协议名的正则表达式应该是(?:(mailto|ssh|ftp|https?)://)?，注意这个表达式本身捕获了协议名，但不包括://。

服务器
   或是域名，如www.csdn.net；或是IP地址，如192.168.1.1，可带端口号，如192.168.1.1:8080。匹配域名的正则表达式为(?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)+(?:com|net|edu|biz|gov|org|in(?:t|fo)|(?-i:[a-z][a-z]))，表达式"(?:com|net|edu|biz|gov|org|in(?:t|fo)"匹配了com、net、edu、biz、gov、org、int、info等常见的域名，而(?-i:[a-z][a-z])匹配了国家代码，而且只允许小写为合法的，如www.richcomm.com.cn。匹配IP要尽量精确，考虑到IP每部分应为数字且范围在0-255之间，因此表达式应为(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.(?:[01]?\d\d?|2[0-4]\d|25[0-5])。注意以上域名或IP的正则式本身不捕获它们，这是为了留在后面作为整体捕获。
   端口号的正则表达式为(?::(\d{1,5}))?，这里限制了端口号为1至5位的数字，更精确的匹配如要求在某范围如[1024,65535]间则可参考以上IP正则模式。综上所得，匹配服务器的正则表达式为((?:(?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)+(?:com|net|edu|biz|gov|org|in(?:t|fo)|(?-i:[a-z][a-z]))|(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.(?:[01]?\d\d?|2[0-4]\d|25[0-5])))(?::(\d{1,5}))?，这个正则式作为整体捕获了域名或IP，及端口号（若有），如www.csdn.net，则得到www.csdn.net和空（没有端口，http默认为80，https默认为443）子串；192.168.1.1:8080则得到192.168.1.1和8080子串。

路径
最简单的形式为(/.*)?，更精确的形式为/[^.!,?;"'<>()\[\]{}\s\x7F-\xFF]*(?:[.!,?]+[^.!,?;"'<>()\[\]{}\s\x7F-\xFF]+)*。

   以上所有正则表达式均为ascii字符集，对于unicode字符集则在其前加L即可。

   为方便使用，封装成了两个自由模板函数，如下所示

1template<typename charT>
2inline bool boost_match(const charT* pattern,const charT* text,unsigned int flags=boost::regex::normal,boost::match_results<const charT*>* result=NULL)
3{
4    boost::basic_regex<charT,boost::regex_traits<charT> > expression(pattern,flags);
5    if(NULL==result)
6        return boost::regex_match(text,expression);
7    return boost::regex_match(text,*result,expression);
8}
9
10template<typename charT>
11inline bool boost_search(const charT* pattern,const charT* text,unsigned int flags=boost::regex::normal,boost::match_results<const charT*>* result=NULL)
12{
13    boost::basic_regex<charT,boost::regex_traits<charT> > expression(pattern,flags);
14    if(NULL==result)
15        return boost::regex_search(text,expression);
16    return boost::regex_search(text,*result,expression);
17}

测试示例如下

1static const string protocol = "(?:(mailto|ssh|ftp|https?)://)?";
2static const string hostname = "(?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\\.)+(?:com|net|edu|biz|gov|org|in(?:t|fo)|(?-i:[a-z][a-z]))";
3static const string ip = "(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])";
4static const string port = "(?::(\\d{1,5}))?";
5static const string path = "(/.*)?";
6static const string pattern = protocol + "((?:" + hostname + "|" + ip + "))" + port + path;
7
8int _tmain(int argc, _TCHAR* argv[])
9{
10    using namespace boost;
11
12    //形式1: 带协议名,服务器为名称,不带端口号
13    bool ret;
14    string text = "http://www.cppblog.com/qinqing1984";
15    boost::cmatch what;
16    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
17    assert(ret);
18    assert(what[1].str()=="http");
19    assert(what[2].str()=="www.cppblog.com");
20    assert(what[3].str()=="");
21    assert(what[4].str()=="/qinqing1984");
22
23    //形式2: 不带协议名,服务器为名称,带端口号
24    text = "www.cppblog.com:80/qinqing1984";
25    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
26    assert(ret);
27    assert(what[1].str()=="");
28    assert(what[2].str()=="www.cppblog.com");
29    assert(what[3].str()=="80");
30    assert(what[4].str()=="/qinqing1984");
31
32    //形式3: 不带协议名,服务器为名称,不带路径
33    text = "www.cppblog.com:80";
34    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
35    assert(ret);
36    assert(what[1].str()=="");
37    assert(what[2].str()=="www.cppblog.com");
38    assert(what[3].str()=="80");
39    assert(what[4].str()=="");
40
41    //形式4: 协议为https,服务器为IP,带端口号
42    text = "https://192.168.1.1:443/index.html";
43    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
44    assert(ret);
45    assert(what[1].str()=="https");
46    assert(what[2].str()=="192.168.1.1");
47    assert(what[3].str()=="443");
48    assert(what[4].str()=="/index.html");
49
50    //形式5: 端口超过5位数
51    text = "ftp://192.168.1.1:888888";
52    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
53    assert(!ret);
54
55    //形式6: 没有协议名
56    text = "//192.168.1.1/index.html";
57    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
58    assert(!ret);
59
60    //形式7: 没有服务器
61    text = "http:///index.html";
62    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
63    assert(!ret);
64
65    //形式8: 不合法的服务器
66    text = "cppblog/index.html";
67    ret=boost_match(pattern.c_str(),text.c_str(),regex::icase|regex::perl,&what);
68    assert(!ret);
69
70    return 0;
71}

对URL的解析，因时间有限，本文所述不尽详细，只是略作分析，以点带面，更多的精确匹配则依赖于实际的应用需求。

春秋十二月 2011-11-27 17:22 发表评论

基于stl序列容器实现的通用集合类 (线程安全版)

春秋十二月 — Fri, 21 Oct 2011 10:43:00 GMT

摘要: 在《基于stl序列容器实现的通用集合类》一文中，已经讲到了具体实现，近来因再次用到它又改进完善了，主要体现在以下几点：1）增加了查找操作方法，支持按值类型和谓词条件两种方式。2）增加重载了按值类型和谓词条件2种方式删除元素的方法。3）增加了2个模板参数以支持线程安全，一个是线程模型模板类，一个是互斥锁类，使用loki库来实现，因此所有方法现在都是线程安全的，当需... 阅读全文

春秋十二月 2011-10-21 18:43 发表评论

基于stl序列容器实现的通用集合类

春秋十二月 — Sat, 16 Jul 2011 04:23:00 GMT

摘要: 在面向对象开发时，对实际问题分析进而抽象出一种类型，往往会考虑到2个方面：1）类型的内部成员和方法的定义描述 2）类型的多实例存取操作。其中第1点是类型本身数据结构的设计，第2点是类型容器数据结构的选择设计。在stl中，容器有序列式和关联式两种，前者代表有vector，list，deque等；后者代表有set，multiset，map，multimap等，对于一... 阅读全文

春秋十二月 2011-07-16 12:23 发表评论

空基类优化EBO之深度探索

春秋十二月 — Sun, 10 Jul 2011 04:58:00 GMT

继承情景
我们知道一个空的类，也就是其内部没有非静态数据成员，没有虚指针（包括指向虚函数表和虚基类子对象的指针），它的大小通常为1，当然在某些对齐要求严格系统上可能是另一个数（通常是4），如果空类被继承，那么派生类的大小会怎么样呢？一个支持C++标准和EBO的编译器对此会进行空基类的优化，也就是不给空的基类子对象分配空间，换句话说，空基类子对象的地址和其派生类实例的地址是相同的。从编译器实现的角度来看，需要考虑继承时的不同情况，下图中P表示父类，C表示子类，圆形表示空类，矩形表示非空类。单继承EBO情况如下图所示

EBO-1反映的是空类派生自空基类，EBO-2反映的是非空类派生自空基类，EBO-3、EBO-4反映的是在继承链中，对空基类的优化能不能传递到后代中。多继承EBO如下图所示

EBO-5反映的是空类派生自两个空基类，EBO-6反映的是非空类派生自两个空基类，EBO-6反映的是空类派生自一个非空基类和一个空基类，EBO-7反映的是非空类派生自一个非空基类和一个空基类。以上8种情况，不论是单继承还是多继承，一个完全支持EBO的编译器就应该能把空基类部分都优化掉。

优化应用
由于空基类优化技术节省了对象不必要的空间，提高了运行效率，因此成为某些强大技术的基石，基于类型定义类如stl中的binary_function、unary_function、iterator、iterator_traits的实现复用；基于策略类如内存管理、多线程安全同步的实现复用。当某个类存在空类类型的数据成员时，也可考虑借助EBO优化对象布局，例如下

1template<typename T1,typename T2>
2class EBO
3{
4private:
5 T1 m_t1;
6 T2 m_t2;
7};

当T1和T2为空类时，可以改进如下

1template<typename T1,typename T2>
2class EBO : T1, T2
3{
4};

更进一步，如果T1或T2为非类类型，如基本内建类型、函数指针等；或T1和T2类型相同时，则直接继承它们会导致编译错误，怎么办呢？这时可以添加一个中间层来解决，代码如下

1template<typename T1,typename T2,bool isSame,bool isFirstEmpty,bool isSecondEmpty>
2class EBO_IMPL;
3
4template<typename T1,typename T2>
5class EBO_IMPL<T1,T2,false,false,false>
6{
7    T1 m_t1;
8    T2 m_t2;
9};
10
11template<typename T1,typename T2>
12class EBO_IMPL<T1,T2,false,true,true> : T1,T2
13{
14};
15
16template<typename T1,typename T2>
17class EBO_IMPL<T1,T2,false,true,false> : T1
18{
19    T2 m_t2;
20};
21
22template<typename T1,typename T2>
23class EBO_IMPL<T1,T2,false,false,true> : T2
24{
25    T1 m_t1;
26};
27
28template<typename T1,typename T2>
29class EBO_IMPL<T1,T2,true,false,false>
30{
31    T1 m_t1;
32    T2 m_t2;
33};
34
35template<typename T1,typename T2>
36class EBO_IMPL<T1,T2,true,true,true> : T1
37{
38    T2 m_t2;
39};
40
41template<typename T1,typename T2>
42class EBO : EBO_IMPL<T1,T2,boost::is_same<T1,T2>::value,boost::is_empty<T1>::value,boost::is_empty<T2>::value>
43{
44};

为了简便，直接使用了boost中的is_same，is_empty元函数来判断类型的属性，实际上boost中已经实现了EBO的选择运用工具即compressed_pair类模板，研究其源码可发现，该工具充分考虑到了T1和T2实际类型的各种情况，is_empty的判断是运用sizeof来比较类型大小确定的。替换compressed_pair后，代码如下

1template<typename T1,typename T2>
2class EBO: boost::compressed_pair<T1,T2>
3{
4};

春秋十二月 2011-07-10 12:58 发表评论

删除vector容器内的重复元素

春秋十二月 — Sat, 25 Jun 2011 06:49:00 GMT

原题为某著名软件公司的试题，大意如下：给定一个容器，要求删除容器中重复的元素，并保持剩余元素的顺序不变。在这里，本文为了全面通用考虑，作了扩展，删除vector中的重复元素，从容器中元素顺序上可分为2种情形：1）保持剩余元素顺序不变，特称为稳定删除，对应下面的stable_unique版本函数模板 2）不考虑顺序变化，特称为快速删除。对应下面的quick_unique版本函数模板。从重复的概念定义也可分为2种情况：1）基于简单的相等判断 2）基于谓词的等价判断。因此，由排列组合得知应该有4种版本的实现，下面给出代码描述

1//函数对象模板类
2template<typename T>
3struct Predicate
4{
5    Predicate()
6    {
7    }
8
9    Predicate(const T& t)
10        :_t(t)
11    {
12    }
13    bool operator()(const T& t) const
14    {
15        //可以自定义比较实现
16        return _t == t;
17    }
18    //支持std::unique谓词版本的删除
19    bool operator()(const T& l,const T& r) const
20    {
21        //可以自定义比较实现
22        return l == r;
23    }
24    T _t;
25};
26
27//quick_unique版本1: 相等判断
28template<typename T>
29void quick_unique(std::vector<T>& con)
30{
31    std::sort(con.begin(),con.end());
32    con.erase(std::unique(con.begin(),con.end()),con.end());
33}
34
35//quick_unique版本2: 谓词判断
36template<typename T,template <typename U> class Predicate>
37void quick_unique(std::vector<T>& con)
38{
39    std::sort(con.begin(),con.end());
40    con.erase(std::unique(con.begin(),con.end(),Predicate<T>()),con.end());
41}
42
43//stable_unique版本1: 相等判断
44template<typename T>
45void stable_unique(std::vector<T>& con)
46{
47    std::vector<T>::iterator it,ret,beg = con.begin();
48    for (it = ++con.begin();it!=con.end();)
49    {
50        ret = find(beg,it,*it);
51        if (ret != it)
52            it = con.erase(it);
53        else
54            ++it;
55    }
56}
57
58//stable_unique版本2: 谓词判断
59template<typename T,template <typename U> class Predicate>
60void stable_unique(std::vector<T>& con)
61{
62    std::vector<T>::iterator it,ret,beg = con.begin();
63    for (it = ++con.begin();it!=con.end();)
64    {
65        ret = find_if(beg,it,Predicate<T>(*it));
66        if (ret != it)
67            it = con.erase(it);
68        else
69            ++it;
70    }
71}

以上代码在vc2005环境下编译测试通过，再进一步扩展，问题完全可以归类为删除某容器内重复元素，只要再加一个模板的模板参数即可template class Conn;函数的形参类型变为std::Conn就行了，但要注意的是不同平台下对应容器的erase实现所返回的迭代器可能有所差别，比如map要这样写才能在linux上正确工作：conn.erase(it++)。对于特殊的情况，可对以上4个函数作对应的重载（注意，函数模板没有特化的概念）来解决。

春秋十二月 2011-06-25 14:49 发表评论

浅谈ACE中的同步机制

春秋十二月 — Thu, 02 Apr 2009 08:33:00 GMT

ACE中的同步机制是轻量级高效的，它不同于MFC中的同步类，MFC中的同步类采用了类继承的方式，而ACE并没有用继承方式，各个不同的锁类是平行的关系，这些类支持相同的接口，即它们的所有公共方法是相同的，因此可被适配用于动态绑定和替换，这种动态绑定是没有虚函数调用开销的,且这些方法代码短小使用了内联实现。应用程序开发者可以通过指定模板实参来使用不同的锁，并可在运行时动态替换。

ACE中的锁是易于使用的，既有互斥锁(ACE_Mutex)又有读写锁(ACE_RW_Mutex)，这些锁又细分为专门用于线程同步(ACE_Thread_Mutex,ACE_RW_Thread_Mutex)和进程(ACE_Process_Mutex,ACE_RW_Process_Mutex)同步的特定锁。相比MFC高级的是ACE中还提供了递归互斥体(ACE_Token)，可有效地用于某些递归例程。

ACE中提供了ACE_Lock锁抽象基类和ACE_Adapter_Lock锁适配器模板类，ACE_Adapter_Lock从ACE_Lock继承，实现了动态绑定和替换。另外，ACE还提供了ACE_Atomic_Op模板类，重载了基本的算术运算符，实现了原子化算术运算。

春秋十二月 2009-04-02 16:33 发表评论

C++博客-一年十二月 谁主春秋-随笔分类-Opensrc