正则表达式

u/a7a:n;G#`0LUPA开源社区Y,D,L2W F$h&S
   在GNU C 中要使用规则表达式，需要用到以下几个函数。（定义在/usr/include/regex.h文件中）  LUPA开源社区\S*U2j'|g
* int regcomp (regex_t *compiled, const char *pattern, int cflags)  LUPA开源社区\P(H+lU7p
* int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr [], int eflags) 
PdBz.|,Gn0* void regfree (regex_t *compiled)  LUPA开源社区FFc`P#wt
* size_t regerror (int errcode, regex_t *compiled, char *buffer, size_t length) 
q9d$V ^cM7v.Y0 
#gb']7z N.eX|c01.int regcomp (regex_t *compiled, const char *pattern, int cflags)  LUPA开源社区1~ C0oq&hY7{

    这个函数把指定的规则表达式pattern编译成一种特定的数据格式compiled，这样可以使匹配更有效。函数 LUPA开源社区;D&y,~5` D
regexec 会使用这个数据在目标文 
7wh?@/Mj\0本串中进行模式匹配。执行成功返回０。 

    regex_t 是一个结构体数据类型，用来存放编译后的规则表达式，它的成员re_nsub 用来存储规则表达式中的子
7K|#WsQ5LM4w0规则表达式的个数，子规则表  LUPA开源社区!S-jSK4D\/A
达式就是用圆括号包起来的部分表达式。 

pattern 是指向我们写好的规则表达式的指针。 
p(u8d F!WE#`0cflags 有如下4个值或者是它们或运算(|)后的值: 
buPG.iE0REG_EXTENDED 以功能更加强大的扩展规则表达式的方式进行匹配。 
1LwCRsR E"^0REG_ICASE 匹配字母时忽略大小写。 
'^:M+N1^'y0REG_NOSUB 不用存储匹配后的结果。 
I'VoI|;~(U"|'CW0REG_NEWLINE 识别换行符，这样$就可以从行尾开始匹配，^就可以从行的开头开始匹配。  LUPA开源社区|?w'd:yOdf

8Osc |!R"E;Y02. int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr [], int eflags)  LUPA开源社区 ik q,oP)ji

%u)Y;T[1fv{`0    当我们编译好规则表达式后，就可以用regexec 匹配我们的目标文本串了，如果在编译规则表达式的时候没有指 LUPA开源社区-p9G^ x)S"j;@
定cflags的参数为 
,H?,T.fQ*|N+U:g(_Z]0REG_NEWLINE，则默认情况下是忽略换行符的，也就是把整个文本串当作一个字符串处理。执行成功返回０。 

J}iD2|'}0    regmatch_t 是一个结构体数据类型，成员rm_so 存放匹配文本串在目标串中的开始位置，rm_eo 存放结束位 LUPA开源社区 cKg)T;GhR`/{
置。通常我们以数组的形式定义一组这样的结构。因为往往我们的规则表达式中还包含子规则表达式。数组0单元存放主规则LUPA开源社区`)QP H2w b*fn
表达式位置，后边的单元依次存放子规则表达式位置。 

/B`-[mg;_0    compiled 是已经用regcomp函数编译好的规则表达式。  LUPA开源社区zJv+Q/Hu0O S:O.z
    string 是目标文本串。  LUPA开源社区%\d.w D3^ W_*u(l"A
    nmatch 是regmatch_t结构体数组的长度。 
];B\0I2`0    matchptr regmatch_t类型的结构体数组，存放匹配文本串的位置信息。 
(YN*b3s$KP |.@z0    eflags 有两个值  LUPA开源社区 o2v M0i~a[
REG_NOTBOL 按我的理解是如果指定了这个值，那么^就不会从我们的目标串开始匹配。总之我到现在还不是很明白这个参数LUPA开源社区B:l,u(@7YK{6n
的意义，  LUPA开源社区g(te OS2dM
原文如下：  LUPA开源社区Otk)WHU-uX
If this bit is set, then the beginning-of-line operator doesnt match the beginning of the LUPA开源社区lA]'zU3m5O
string (presumably  LUPA开源社区d5d3FTN1z,As
because its not the beginning of a line).If not set, then the beginning-of-line operator
5LCqqA)e*U0does match the beginning 
Z&^a%s3c/O0of the string. 
x:qQ4Z6s2PA/|(y0REG_NOTEOL 和上边那个作用差不多，不过这个指定结束end of line。  LUPA开源社区1h*RMYx'b4gT

3. void regfree (regex_t *compiled)  LUPA开源社区 m Aw9u2l,o

    当我们使用完编译好的规则表达式后，或者要重新编译其他规则表达式的时候，我们可以用这个函数清空compiled指向
(M3Z5g[a B0的regex_t结构体的内 
|(K%E.{u(Sd(O0容，请记住，如果是重新编译的话，一定要先清空regex_t结构体。 

4. size_t regerror (int errcode, regex_t *compiled, char *buffer, size_t length)  LUPA开源社区 fu8qK0~`
    当执行regcomp 或者regexec 产生错误的时候，就可以调用这个函数而返回一个包含错误信息的字符串。 

b(?f q9iY0    errcode 是由regcomp 和 regexec 函数返回的错误代号。  LUPA开源社区*tf ^ }'x
    compiled 是已经用regcomp函数编译好的规则表达式，这个值可以为NULL。 
,DW0}%mMJ:i t6^X0    buffer 指向用来存放错误信息的字符串的内存空间。 
YH ` ]Id0    length 指明buffer的长度，如果这个错误信息的长度大于这个值，则regerror 函数会自动截断超出的字符串,但他仍然LUPA开源社区.o;X;h0EP[1q`-DkF
会返回完整的字符串的长度。所以我们可以用如下的方法先得到错误字符串的长度。  LUPA开源社区 w-Hf&w4K
size_t length = regerror (errcode, compiled, NULL, 0); 

LUPA开源社区0q[ `d4UJOs/u?J
应用正则表达式 LUPA开源社区
gq6L]y5I!q[
如何在C语言程序中处理正则表达式。 LUPA开源社区n&J\2gq PK+Z8F

Hw?~ G&h0#include <stdio.h> LUPA开源社区C$AA&~/f
#include <sys/types.h>
lA+u\!qP}+S0#include <regex.h>
3n6a5k|cJiH0/* 取子串的函数 */
NQu3}"N0static char* substr(const char*str, unsigned start, unsigned end) LUPA开源社区3P*u!^Q*bzm}"R

E(SpK;dick0{
1Y^ B a g;Bf'aw0 unsigned n = end - start;
X%lLo7O reD:oT"q^0    static char stbuf[256];
GV!GC9h0    memset( stbuf, 0x00, sizeof(stbuf));     LUPA开源社区7QjU} o
    strncpy(stbuf, str + start, n);          LUPA开源社区Z`l9`8~*ii7B
    return stbuf; LUPA开源社区,mVEmG8XH
}
oA5V X#BD$aZtn0 
T
?Fv!YV0/* 主程序 */
O}l C"s+m!b\0int main(int argc, char** argv)
$F]T:Vb9C
x0{LUPA开源社区4C3Qa%y7e#| n q
    char *pattern = NULL;    
z/[Cj VN.N3@0    int x, z, lno = 0, cflags = 0;    
`LDz3Lv9@!I0    char ebuf[128], lbuf[256];     LUPA开源社区q8m(S\-da4J
    regex_t reg;    
Jc0gb5B'[a.[j&T'S,D0    regmatch_t pm[10];    
0KI$P fMK } T0    const size_t nmatch = 10;
$vpdG2l[h(e0     LUPA开源社区Mr~Bl(x
    memset( ebuf, 0x00,sizeof( ebuf));LUPA开源社区?1uFhed0@v$Bp
    memset( lbuf, 0x00,sizeof( lbuf));
$g/ni5WT,v?g^i0    memset( pm, 0x00,sizeof( pm));
4r ]*kyyc'V0xS0        LUPA开源社区 S W
Z&_K B-zA`MQX
    /* 编译正则表达式*/    
Ee u^ o&q7@4m0    pattern = argv[1];LUPA开源社区Kt2y } P)|1w#O
         LUPA开源社区2~;`o,}w&y
    z = regcomp(&reg, pattern, cflags);    
cF&}2Ub+H0    if (z != 0)
o&aL ?;Z2J0    {   
*XIC|9Mc1Px2j}0        regerror(z, &reg, ebuf, sizeof(ebuf));         LUPA开源社区6v/B6A3MA
        fprintf(stderr, "%s: pattern '%s' \n", ebuf, pattern);        
(\O2xag-a0        return 1;
d2ir5}u#h*xXs0    }
-W@p
g6Z0    /* 逐行处理输入的数据 */    
^,jW$NVz*L ][0    while(fgets(lbuf, sizeof(lbuf), stdin))
8_J2?uf'd0    {   
%t1S&hzQ(f0        ++lno;         LUPA开源社区x6M0ID:I+^H
        if ((z = strlen(lbuf)) > 0 && lbuf[z-1] == '\n')        
{8BnIF;M?@(`0        lbuf[z - 1] = 0;        
'pm9j6S8X.]co0        /* 对每一行应用正则表达式进行匹配 */        
mhc!J!pOmj7F ` m0        z = regexec(&reg, lbuf, nmatch, pm, 0);        
ckD2n1y|0        if (z == REG_NOMATCH)

h.gGrNR0        {LUPA开源社区al3TZs6H6z
         continue;LUPA开源社区|;i'z{3`M)O
        }        
v!X"N.G;So0        else if (z != 0) LUPA开源社区%Yd2`\%[G(p_
        {       
0` kf7v
L6e$e0            regerror(z, &reg, ebuf, sizeof(ebuf));             LUPA开源社区P#CQ.gJ-E4V6?4yb
            fprintf(stderr, "%s: regcom('%s')\n", ebuf, lbuf);            
UW]%\+[Llg-|0            return 2;        
D dARQ b0        }     LUPA开源社区:N$`vR3jf
    /* 输出处理结果 */     LUPA开源社区qT/A)`f
        for ( x = 0; x < nmatch && pm[x].rm_so != -1; ++ x )
4gH!h.ul+O0        {        LUPA开源社区 c-d&?d%g2DL F
            if (!x)
~p-IA#Cx~0            {LUPA开源社区kWp3gU1yy
             printf("%04d: %s\n", lno, lbuf);
E2eb#~`I0            }             LUPA开源社区7v)]2gElCr;q#~
            printf(" $%d='%s'\n", x, substr(lbuf, pm[x].rm_so, pm[x].rm_eo));     LUPA开源社区k-r3d}6G_}\yc
        }    
8l g q+I$H'J \H0    }     LUPA开源社区-AE5m"A\]
    /* 释放正则表达式 */    
RCSB2\6?\0    regfree(&reg);    
S3H:vK[}+y0    return 0;    
/Z"F0]TW8~o mHq0}
'jj"U,Rr KE9e0LUPA开源社区)JP1{,th }*M

    上述程序负责从命令行获取正则表达式，然后将其运用于从标准输入得到的每行数据，并打印出匹配结果。执行下面
f]+h^b:M0的命令可以编译并执行该程序：
;L/J,qS5a{!^\ K0 LUPA开源社区ghq1F:v"yj
# gcc regexp.c -o regexp
Yl;e1V5y+z0# ./regexp 'regex[a-z]*' < regexp.c
&k9|"jt7ly00003: #include <regex.h> LUPA开源社区#Rsd0g(k ~IW1k
$0='regex'
|9_)V)L'i)Am*^*y00027: regex_t reg; LUPA开源社区rdc~8W{`)j
$0='regex' LUPA开源社区OuX5J$c @kAUY1{
0054: z = regexec(?, lbuf, nmatch, pm, 0);
(u/D1arg Hm0$0='regexec'

?o$d-P$Fu8d/cJ"b0小结
;NC#]?Mbw H0    对那些需要进行复杂数据处理的程序来说，正则表达式无疑是一个非常有用的工具。本文重点在于阐述如何在C语言中利用正则表达式来简化字符串处理，以便在数据处理方面能够获得与Perl语言类似的灵活性。

LUPA开源社区e,s7l4H;B*]
 LUPA开源社区#NSQtB"H

 LUPA开源社区k-`0sJCIl