C语言正则表达式

首页 > 代码库 > C语言正则表达式

2024-09-15 08:59:24 219人阅读

#include <sys/types.h>
#include <regex.h>

int regcomp(regex_t *preg, const char *regex, int cflags);

int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);

size_t regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size);

void regfree(regex_t *preg);

Description

POSIX regex compiling

regcomp() is used to compile a regular expression into a form that is suitable for subsequent regexec() searches.

regcomp() is supplied with preg, a pointer to a pattern buffer storage area; regex, a pointer to the null-terminated string and cflags, flags used to determine the type of compilation.

All regular expression searching must be done via a compiled pattern buffer, thus regexec() must always be supplied with the address of aregcomp() initialized pattern buffer.

cflags may be the bitwise-or of one or more of the following:

REG_EXTENDED

Use POSIX Extended Regular Expression syntax when interpreting regex. If not set, POSIX Basic Regular Expression syntax is used.

REG_ICASE

Do not differentiate case. Subsequent regexec() searches using this pattern buffer will be case insensitive.

REG_NOSUB

Do not report position of matches. The nmatch and pmatch arguments to regexec() are ignored if the pattern buffer supplied was compiled with this flag set.

REG_NEWLINE

Match-any-character operators don‘t match a newline.

A nonmatching list ([^...]) not containing a newline does not match a newline.

Match-beginning-of-line operator (^) matches the empty string immediately after a newline, regardless of whether eflags, the execution flags of regexec(), contains REG_NOTBOL.

Match-end-of-line operator ($) matches the empty string immediately before a newline, regardless of whether eflags contains REG_NOTEOL.

POSIX regex matching

regexec() is used to match a null-terminated string against the precompiled pattern buffer, preg. nmatchand pmatch are used to provide information regarding the location of any matches. eflags may be the bitwise-or of one or both of REG_NOTBOL and REG_NOTEOL which cause changes in matching behavior described below.
REG_NOTBOL: The match-beginning-of-line operator always fails to match (but see the compilation flagREG_NEWLINE above) This flag may be used when different portions of a string are passed toregexec() and the beginning of the string should not be interpreted as the beginning of the line.
REG_NOTEOL: The match-end-of-line operator always fails to match (but see the compilation flag REG_NEWLINEabove)

Byte offsets

Unless REG_NOSUB was set for the compilation of the pattern buffer, it is possible to obtain match addressing information. pmatch must be dimensioned to have at least nmatch elements. These are filled in by regexec() with substring match addresses. The offsets of the subexpression starting at the ith open parenthesis are stored in pmatch[i]. The entire regular expression‘s match addresses are stored inpmatch[0]. (Note that to return the offsets of N subexpression matches, nmatch must be at least N+1.) Any unused structure elements will contain the value -1.

The regmatch_t structure which is the type of pmatch is defined in <regex.h>.

typedef struct {
    regoff_t rm_so;
    regoff_t rm_eo;
} regmatch_t;

Each rm_so element that is not -1 indicates the start offset of the next largest substring match within the string. The relative rm_eo element indicates the end offset of the match, which is the offset of the first character after the matching text.

POSIX error reporting

regerror() is used to turn the error codes that can be returned by both regcomp() and regexec() into error message strings.

regerror() is passed the error code, errcode, the pattern buffer, preg, a pointer to a character string buffer, errbuf, and the size of the string buffer, errbuf_size. It returns the size of the errbuf required to contain the null-terminated error message string. If both errbuf and errbuf_size are nonzero, errbuf is filled in with the first errbuf_size - 1 characters of the error message and a terminating null byte (‘\0‘).

POSIX pattern buffer freeing

Supplying regfree() with a precompiled pattern buffer, preg will free the memory allocated to the pattern buffer by the compiling process, regcomp().

Return Value

regcomp() returns zero for a successful compilation or an error code for failure.

regexec() returns zero for a successful match or REG_NOMATCH for failure.

Errors

The following errors can be returned by regcomp():

REG_BADBR: Invalid use of back reference operator.
REG_BADPAT: Invalid use of pattern operators such as group or list.
REG_BADRPT: Invalid use of repetition operators such as using ‘*‘ as the first character.
REG_EBRACE: Un-matched brace interval operators.
REG_EBRACK: Un-matched bracket list operators.
REG_ECOLLATE: Invalid collating element.
REG_ECTYPE: Unknown character class name.
REG_EEND: Nonspecific error. This is not defined by POSIX.2.
REG_EESCAPE: Trailing backslash.
REG_EPAREN: Un-matched parenthesis group operators.
REG_ERANGE: Invalid use of the range operator, e.g., the ending point of the range occurs prior to the starting point.
REG_ESIZE: Compiled regular expression requires a pattern buffer larger than 64Kb. This is not defined by POSIX.2.
REG_ESPACE: The regex routines ran out of memory.
REG_ESUBREG: Invalid back reference to a subexpression.


C语言处理正则表达式常用的函数有regcomp()、regexec()、regfree()和regerror()，一般分为三个步骤，如下所示：

C语言中使用正则表达式一般分为三步：

编译正则表达式 regcomp()
匹配正则表达式 regexec()
释放正则表达式 regfree()

下边是对三个函数的详细解释


1、int regcomp (regex_t *compiled, const char *pattern, int cflags)
这个函数把指定的正则表达式pattern编译成一种特定的数据格式compiled，这样可以使匹配更有效。函数regexec 会使用这个数据在目标文本串中进行模式匹配。执行成功返回０。 　
参数说明：
①regex_t 是一个结构体数据类型，用来存放编译后的正则表达式，它的成员re_nsub 用来存储正则表达式中的子正则表达式的个数，子正则表达式就是用圆括号包起来的部分表达式。
②pattern 是指向我们写好的正则表达式的指针。
③cflags 有如下4个值或者是它们或运算(|)后的值：
REG_EXTENDED 以功能更加强大的扩展正则表达式的方式进行匹配。
REG_ICASE 匹配字母时忽略大小写。
REG_NOSUB 不用存储匹配后的结果。
REG_NEWLINE 识别换行符，这样‘$‘就可以从行尾开始匹配，‘^‘就可以从行的开头开始匹配。

2. int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr [], int eflags)
当我们编译好正则表达式后，就可以用regexec 匹配我们的目标文本串了，如果在编译正则表达式的时候没有指定cflags的参数为REG_NEWLINE，则默认情况下是忽略换行符的，也就是把整个文本串当作一个字符串处理。执行成功返回０。
regmatch_t 是一个结构体数据类型，在regex.h中定义：             
typedef struct
{
   regoff_t rm_so;
   regoff_t rm_eo;
} regmatch_t;
成员rm_so 存放匹配文本串在目标串中的开始位置，rm_eo 存放结束位置。通常我们以数组的形式定义一组这样的结构。因为往往我们的正则表达式中还包含子正则表达式。数组0单元存放主正则表达式位置，后边的单元依次存放子正则表达式位置。
参数说明：
①compiled 是已经用regcomp函数编译好的正则表达式。
②string 是目标文本串。
③nmatch 是regmatch_t结构体数组的长度。
④matchptr regmatch_t类型的结构体数组，存放匹配文本串的位置信息。
⑤eflags 有两个值
REG_NOTBOL 按我的理解是如果指定了这个值，那么‘^‘就不会从我们的目标串开始匹配。总之我到现在还不是很明白这个参数的意义；
REG_NOTEOL 和上边那个作用差不多，不过这个指定结束end of line。

3. void regfree (regex_t *compiled)
当我们使用完编译好的正则表达式后，或者要重新编译其他正则表达式的时候，我们可以用这个函数清空compiled指向的regex_t结构体的内容，请记住，如果是重新编译的话，一定要先清空regex_t结构体。

4. size_t regerror (int errcode, regex_t *compiled, char *buffer, size_t length)
当执行regcomp 或者regexec 产生错误的时候，就可以调用这个函数而返回一个包含错误信息的字符串。
参数说明：
①errcode 是由regcomp 和 regexec 函数返回的错误代号。
②compiled 是已经用regcomp函数编译好的正则表达式，这个值可以为NULL。
③buffer 指向用来存放错误信息的字符串的内存空间。
④length 指明buffer的长度，如果这个错误信息的长度大于这个值，则regerror 函数会自动截断超出的字符串，但他仍然会返回完整的字符串的长度。所以我们可以用如下的方法先得到错误字符串的长度。

size_t length = regerror (errcode, compiled, NULL, 0);

正则表达式示例表
字符意义示例
* 任意长度的字符串。 a* 表示: 空字符串、aaaa、a…
? 长度为0或者1的字符串。 a? 表示: 空字符串和a。
+ 长度为一个或者多个的字符串。 a+表示:a、aa、aaaaaa…
. 任意字符。 a. 表示:a后跟任意字符。
{} 代表上一规则重复数目、
{1,1,s}包含一组匹配花括号，里面有两个数字和一个字符，表示在指定次数范围内找到字符。 a{3}表示:三个a、
a{1,3}表示:一个到三个a、
a{3,} 表示:大于等于三个a、
{3，7，a}表示在3到7次重复范围内匹配字符a。
[] 集合,代表方括号中任意一个字符。 [ab] 表示:a或者b都可以、
[a-z] 表示:从a到z的字符。
() 组,代表一组字符。 (ab){2}表示:abab。
a/b 同时满足。 a/b表示:字符串a后跟字符串b才能满足要求。
a|b 并列,代表符合a或者符合b都可以 a|b表示: 字符串a或者字符串b都满足要求。
^ 如果放在开头表示代表该规则必须在字符串的开头，其他位置代表字符本身。
如果放在[]中的开头表示对该集合取反,其他位置代表字符本身。 ^a表示:a必须在字符串的开头、
[^a]表示:除了a以外的其他字符。
$ 如果放在最后表示该规则必须放在最后,其他位置代表字符本身。 a$表示:a必须在字符串最后。
/:s 正则表达式用 /:s 表示空格。 a/:sb 匹配 a b。
/:a 正则表达式用 /:a 表示字符与数字。 a/:a 匹配 ab、a6 等。
/:c 正则表达式用 /:c 仅表示字符。 a/:c 匹配 ac等，不匹配a1等。
/:p 正则表达式用 /:p 表示可打印字符。
/:D 正则表达式用 /:d 仅表示数字。 a/:c 匹配 a1等，不匹配ac等。
/:x00 正则表达式用 /:x00 表示ASCII字符。
/:r 正则表达式用 /:r 表示回车。
/:N 正则表达式用 /:d 表示换行。

 1 #include <stdio.h>  
 2 #include <sys/types.h>  
 3 #include <regez.h>  
 4   
 5 in chk_line(int lineno, regex_t *reg,char *line)  
 6 {  
 7     int rtn,i,len;  
 8     regmatch_t pmatch;  
 9     char *url,*pbuf;  
10   
11     fprintf(stderr,"%4d",lineno);  
12     rtn = regexec(reg,line,1,&pmatch,0);  
13     pbuf = line;  
14     while(rtn == 0)  
15     {  
16         len = pmatch.rm_eo - pmatch.rm_so;  
17         url = (char*)malloc((len+1)*sizeof(char));  
18         memset(url,0,(len+1)*sizeof(char));  
19         memcpy(url,&pbuf[pmatch.rm_so].len);  
20         fprintf(stderr,"%s",url);  
21         free(url);  
22         pbuf += pmatch.rm_eo;  
23         rtn = regexec(reg,pbuf,1,&pmatch,REG_NOTBOL);  
24     }  
25     fprintf(stderr,"/n");  
26     return 0;  
27 }  
28 int chk_file(const char *filename)  
29 {  
30     FILE *fp;  
31     char *pattern = "^(hisencyber)(.com|.com.cn)";  
32     char buf[1024],line[1024];  
33     int rtn,lineno,flag;  
34   
35     fp = fopen(filename,"r");  
36     if(fp == NULL)  
37     {  
38         fprintf(stderr,"OPen file failed/n",filename);  
39         return -1;  
40     }  
41     rtn = Regcomp(?,patten,REG_ICASE|REG_EXTENDED);  
42     if(rtn)  
43     {  
44         fprintf(stderr,"compile failed./n");  
45         fclose(fp);  
46         return -1;  
47     }  
48     lineno = 1;  
49     memset(line,0,sizeof(line));  
50     while(fgets(line,sizeof(line),fp)!= NULL)  
51     {  
52         chk_line(lineno++,?,line);  
53     }  
54     fclose(fp);  
55     regefree(?);  
56     return 0;  
57 }  
58 int main (int argc,char *argv[])  
59 {  
60     int rtn;  
61     if(argc != 2)  
62     {  
63         fprintf(stderr,"Usage:chkfileurl <file> /n ");  
64         return 1;  
65     }  
66     rtn = chk_file(argv[1]);  
67     return rtn;  
68 }

C语言正则表达式

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > C语言正则表达式