C语言中的正则表达式使用示例详解

正则表达式,又称正规表示法、常规表示法(英语:Regular Expression,在代码中常简写为regex、regexp或RE)。正则表达式是使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。

在c语言中,用regcomp、regexec、regfree 和regerror处理正则表达式。处理正则表达式分三步:

  1. 编译正则表达式,regcomp;
  2. 匹配正则表达式,regexec;
  3. 释放正则表达式,regfree。

函数原型

/*
函数说明:Regcomp将正则表达式字符串regex编译成regex_t的形式,后续regexec以此进行搜索。
参数说明:
  Preg:一个regex_t结构体指针。
  Regex:正则表达式字符串。
  Cflags:是下边四个值或者是他们的或(|)运算。
    REG_EXTENDED:使用POSIX扩展正则表达式语法解释的正则表达式。如果没有设置,基本POSIX正则表达式语法。
    REG_ICASE:忽略字母的大小写。
    REG_NOSUB:不存储匹配的结果。
    REG_NEWLINE:对换行符进行“特殊照顾”,后边详细说明。
返回值:
  0:表示成功编译;
  非0:表示编译失败,用regerror查看失败信息
*/
int regcomp(regex_t *preg, const char *regex, int cflags);
/*
函数说明: Regexec用来匹配正则文本。
参数说明:
  Preg:由regcomp编译好的regex_t结构体指针,
  String:要进行正则匹配的字符串。
  Nmatch:regmatch_t结构体数组的大小
  Pmatch:regmatch_t结构体数组。用来保存匹配结果的子串位置。
  regmatch_t结构体定义如下
    typedef struct {
      regoff_t rm_so;
      regoff_t rm_eo;
    } regmatch_t;
    rm_so,它的值如果不为-1,表示匹配的最大子串在字符串中的起始偏移量,rm_eo,表示匹配的最大字串在字符串的结束偏移量。
  Eflags: REG_NOTBOL和REG_NOTEOL为两个值之一或二者的或(|)运算,稍后会介绍。
返回值:
  0:表示成功编译;
  非0:表示编译失败,用regerror查看失败信息
*/
int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
/*
函数说明:用来释放regcomp编译好的内置变量。
参数说明:
  Preg:由regcomp编译好的regex_t结构体指针。
*/
void regfree(regex_t *preg);
/*
函数说明:Regcomp,regexec出错时,会返回error code并且为非0,此时就可以用regerror得到错误信息。
参数说明:
  Errcode:Regcomp,regexec出错时的返回值
  Preg:经过Regcomp编译的regex_t结构体指针。
  Errbuf:错误信息放置的位置。
  errbuf_size:错误信息buff的大小。
*/
size_t regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size);

示例一

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <regex.h>
int main (void)
{
  char ebuff[256];
  int ret;
  int cflags;
  regex_t reg;
  cflags = REG_EXTENDED | REG_ICASE | REG_NOSUB;
  char *test_str = "Hello World";
  char *reg_str = "H.*";
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "%s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "%s\n", ebuff);
    goto end;
  }
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "result is:\n%s\n", ebuff);
end:
  regfree(&reg);
  return 0;
}

编译,输出结果:

[root@zxy regex]# ./test
result is:
Success

匹配成功。

示例二

如果我想保留匹配的结果怎么操作?那就得用到 regmatch_t 结构体了。重新改写上边代码,这时就不能用REG_NOSUB选项了,代码如下:

#define _GNU_SOURCE
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <regex.h>
int main (void)
{
  int i;
  char ebuff[256];
  int ret;
  int cflags;
  regex_t reg;
  regmatch_t rm[5];
  char *part_str = NULL;
  cflags = REG_EXTENDED | REG_ICASE;
  char *test_str = "Hello World";
  char *reg_str = "e(.*)o";
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "%s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 5, rm, 0);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "%s\n", ebuff);
    goto end;
  }
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "result is:\n%s\n\n", ebuff);
  for (i=0; i<5; i++)
  {
    if (rm[i].rm_so > -1)
    {
      part_str = strndup(test_str+rm[i].rm_so, rm[i].rm_eo-rm[i].rm_so);
      fprintf(stderr, "%s\n", part_str);
      free(part_str);
      part_str = NULL;
    }
  }
end:
  regfree(&reg);
  return 0;
}

编译,输出结果:

[root@zxy regex]# ./test
result is:
Success
ello Wo
llo W

  咦??????我明明只要一个匹配结果,为什么会打印两个出来呢???????
  原来regmatch_t数组的第一个元素是有特殊意义的:它是用来保存整个正则表达式能匹配的最大子串的起始和结束偏移量。所以我们在设置regmatch_t数组个数的时候一定要记住,它的个数是最大保留结果数+1。

REG_NEWLINE、REG_NOTBOL和REG_NOTEOL

好了,基本的正则运用到此为止了,现在要开始讲讲REG_NEWLINE、REG_NOTBOL和REG_NOTEOL。很多人对这三个参数有所迷惑。我也是,昨天有人问问题,就把自己错误的理解告诉了别人,然后被大神一顿鄙视。我一直认为如果想用^和$这两个匹配模式一定要用到REG_NEWLINE这个参数,其实不然。

REG_NEWLINE

首先看下man page对REG_NEWLINE的说明:

REG_NEWLINE
  Match-any-character operators don't match a newline.
  A non-matching 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.

我英文不好,google翻译之。。

REG_NEWLINE

  1.匹配任何字符的运算符(比如.)不匹配换行('\n');
  2.非匹配列表([^...])不包含一个换行符不匹配一个换行符;
  3.匹配开始运算符(^)遇到空字符串立即换行,不论在执行regexec()时,eflags是否设置了REG_NOTBOL;
  4.匹配结束运算符($)遇到空字符串立即换行,不论在执行regexec()时,eflags是否设置了REG_NOTEOL;

不明白说的是什么,程序测之。。

第一个问题

代码如下:

#define _GNU_SOURCE
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <regex.h>
int main (void)
{
  int i;
  char ebuff[256];
  int ret;
  int cflags;
  regex_t reg;
  cflags = REG_EXTENDED | REG_ICASE | REG_NOSUB;
  char *test_str = "Hello World\n";
  char *reg_str = "Hello World.";
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "1. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "2. %s\n", ebuff);
  cflags |= REG_NEWLINE;
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "3. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "4. %s\n", ebuff);
end:
  regfree(&reg);
  return 0;
}

  编译,运行结果如下:

[root@zxy regex]# ./test
2. Success
4. No match

  结果很明显:没有加入REG_NEWLINE的匹配成功,加入的匹配不成功。就是说不加入REG_NEWLINE,任意匹配字符(.)包含'n',加入则不包含'n'。

第二个问题

代码如下:

#define _GNU_SOURCE
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <regex.h>
int main (void)
{
  int i;
  char ebuff[256];
  int ret;
  int cflags;
  regex_t reg;
  cflags = REG_EXTENDED | REG_ICASE | REG_NOSUB;
  char *test_str = "Hello\nWorld";
  char *reg_str = "Hello[^ ]";
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "1. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "2. %s\n", ebuff);
  cflags |= REG_NEWLINE;
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "3. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "4. %s\n", ebuff);
end:
  regfree(&reg);
  return 0;
}

编译,运行结果如下:

[root@zxy regex]# ./test
2. Success
4. No match

  结果说明:不加入REG_NEWLINE,在一个不包含'n'的非列表中,'n'是不被认作空白符,加入则'n'是被认作空白符。

第三个问题

代码如下:

#define _GNU_SOURCE
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <regex.h>
int main (void)
{
  int i;
  char ebuff[256];
  int ret;
  int cflags;
  regex_t reg;
  cflags = REG_EXTENDED | REG_ICASE | REG_NOSUB;
  char *test_str = "\nHello World";
  char *reg_str = "^Hello";
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "1. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "2. %s\n", ebuff);
  cflags |= REG_NEWLINE;
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "3. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "4. %s\n", ebuff);
end:
  regfree(&reg);
  return 0;
}

编译,运行结果如下:

[root@zxy regex]# ./test
2. No match
4. Success

  结果说明:不加入REG_NEWLINE,'^'是不忽略'n'的,加入REG_NEWLINE,'^'是忽略'n'的。也就是说:不加入REG_NEWLINE,以'n'开头的字符串是不能用'^'匹配,加入REG_NEWLINE,以'n'开头的字符串是可以用'^'匹配。

第四个问题

代码如下:

#define _GNU_SOURCE
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <regex.h>
int main (void)
{
  int i;
  char ebuff[256];
  int ret;
  int cflags;
  regex_t reg;
  cflags = REG_EXTENDED | REG_ICASE | REG_NOSUB;
  char *test_str = "Hello World\n";
  char *reg_str = "d$";
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "1. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "2. %s\n", ebuff);
  cflags |= REG_NEWLINE;
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "3. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "4. %s\n", ebuff);
end:
  regfree(&reg);
  return 0;
}

编译,运行结果如下:

[root@zxy regex]# ./test
2. No match
4. Success

  结果说明:不加入REG_NEWLINE,'&dollar;'是不忽略'n'的,加入REG_NEWLINE,'&dollar;'是忽略'n'的。也就是说:不加入REG_NEWLINE,以'n'结尾的字符串是不能用'​&dollar;'匹配,加入REG_NEWLINE,以'n'开头的字符串是可以用'​&dollar;'匹配。

REG_NEWLINE总结

好,REG_NEWLINE选项测试到此结束。总结下:

  对于REG_NEWLINE选项,1.使用任意匹配符(.)时,任意匹配符不会包含'n';2.对于一个不含有'n'的非列表,会把'n'认作空白符。3.对于以'n'开头或结尾的字符串,会忽略'n'。使'^'和'$'可以使用。

REG_NOTBOL和REG_NOTEOL

现在开始说下REG_NOTBOL和REG_NOTEOL,首先看下man page对这两选项的说明:

REG_NOTBOL
  The match-beginning-of-line operator always fails to match (but see the compilation flag REG_NEWLINE above) This flag may be used when different portions of a string are passed to regexec() 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_NEWLINE above)
继续googling。

REG_NOTBOL
  匹配开始操作符(^)会经常匹配失败(但是要考虑REG_NEWLINE),这个标志被用在当一个字符串的不同位置被传入到regexec()时,这个位置不应该被解释为该整个字符串的开始位置。
REG_NOTEOL
  匹配结束操作符($)会经常失败(但是要考虑REG_NEWLINE)。(这个标志被用在当一个字符串的不同位置被传入到regexec()时,即使满足匹配结束作符,也不应该被解释为以某字符(串)为结束的)。

  好吧,继续测试,第一个问题代码如下:

#define _GNU_SOURCE
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <regex.h>
int main (void)
{
  int i;
  char ebuff[256];
  int ret;
  int cflags;
  regex_t reg;
  cflags = REG_EXTENDED | REG_ICASE | REG_NOSUB;
  char *test_str = "Hello World\n";
  char *reg_str = "^e";
  ret = regcomp(&reg, reg_str, cflags);
  if (ret)
  {
    regerror(ret, &reg, ebuff, 256);
    fprintf(stderr, "1. %s\n", ebuff);
    goto end;
  }
  ret = regexec(&reg, test_str+1, 0, NULL, 0);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "2. %s\n", ebuff);
  ret = regexec(&reg, test_str+1, 0, NULL, REG_NOTBOL);
  regerror(ret, &reg, ebuff, 256);
  fprintf(stderr, "4. %s\n", ebuff);
end:
  regfree(&reg);
  return 0;
}

编译,运行结果如下:

[root@zxy regex]# ./test
2. Success
4. No match

结果说明:不加入REG_NOTBOL,一个字符串的不同位置是可以用'^'进行匹配,加入REG_NOTBOL,则不能进行匹配。

第二个问题,我实在理解不了了,网上介绍的全是没有经过验证的。。。。。。

总结

以上所述是小编给大家介绍的C语言中的正则表达式使用示例详解,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!
如果你觉得本文对你有帮助,欢迎转载,烦请注明出处,谢谢!

时间: 2019-07-17

C语言正则表达式操作示例

本文实例讲述了C语言正则表达式操作.分享给大家供大家参考,具体如下: #include <stdio.h> #include <sys/types.h> #include <regex.h> int main(int argc,char**argv) { int status; int i; int cflags = REG_EXTENDED; regmatch_t pmatch[1]; const size_t nmatch =1 ; regex_t reg; con

C语言正则表达式详解 regcomp() regexec() regfree()用法详解

标准的C和C++都不支持正则表达式,但有一些函数库可以辅助C/C++程序员完成这一功能,其中最著名的当数Philip Hazel的Perl-Compatible Regular Expression库,许多Linux发行版本都带有这个函数库. C语言处理正则表达式常用的函数有regcomp().regexec().regfree()和regerror(),一般分为三个步骤,如下所示: C语言中使用正则表达式一般分为三步: 编译正则表达式 regcomp() 匹配正则表达式 regexec() 释

c语言 sscanf,scanf,fscanf正则表达式用法

每种语言都对正则表达式有着不同程度的支持,在C语言中,有输入功能的这三个函数对正则表达式的支持并不强大,但是我们还是有必要了解一下. 首先来看看他们的原型: #include <stdio.h> int scanf(const char *format, ...); int fscanf(FILE *stream, const char *format, ...); int sscanf(const char *str, const char *format, ...); 均可以接受变参,ss

Go语言正则表达式用法实例小结【查找、匹配、替换等】

本文实例讲述了Go语言正则表达式用法.分享给大家供大家参考,具体如下: Go语言的正则表达式使用很简单,示例代码: 复制代码 代码如下: package test import (     "fmt"     "regexp" ) func RegixBase() {     //findTest()     //findIndexTest()     //findStringTest()     //findChinesString()     //findNum

详解C语言sscanf()函数、vsscanf()函数、vscanf()函数

C语言sscanf()函数:从字符串中读取指定格式的数据 头文件: #include <stdio.h> sscanf()函数用于从字符串中读取指定格式的数据,其原型如下: int sscanf (char *str, char * format [, argument, ...]); [参数]参数str为要读取数据的字符串:format为用户指定的格式:argument为变量,用来保存读取到的数据. [返回值]成功则返回参数数目,失败则返回-1,错误原因存于errno 中. sscanf()

C语言指针详解及用法示例

新手在C语言的学习过程中遇到的最头疼的知识点应该就是指针了,指针在C语言中有非常大的用处.下面我就带着问题来写下我对于指针的一些理解. 指针是什么? 指针本身是一个变量,它存储的是数据在内存中的地址而不是数据本身的值.它的定义如下: int a=10,*p; p=&a int a=10; int *p=&a; 首先我们可以理解 int* 这个是要定义一个指针p,然后因为这个指针存储的是地址所以要对a取地址(&)将值赋给指针p,也就是说这个指针p指向a. 很多新手都会对这两种定义方法

javascript 正则表达式用法 小结

javascript正则表达式用法: 复制代码 代码如下: function checkreg(myreg,mytext) { if(myreg.test(mytext) { alert("ok"); return true; } else { return false; } } //另一种写法 复制代码 代码如下: function checkreg(myreg,mytext) { var pattern = myreg; //或者 var pattern = new RegExp(

JSP中正则表达式用法实例

本文实例讲述了JSP中正则表达式用法.分享给大家供大家参考,具体如下: <%@ page language="java" import="java.util.*,cn.com.Person,cn.com.Adddress" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+

GO语言映射(Map)用法分析

本文实例讲述了GO语言映射(Map)用法.分享给大家供大家参考.具体如下: 映射是一种内置的数据结构,用来保存键值对的无序集合. (1)映射的创建 make ( map [KeyType] ValueType, initialCapacity ) make ( map [KeyType] ValueType ) map [KeyType ] ValueType {} map [KeyType ] ValueType { key1 : value1, key2: value2, ... , key

Go语言里的new函数用法分析

本文实例讲述了Go语言里的new函数用法.分享给大家供大家参考.具体如下: 表达式 new(T) 分配了一个零初始化的 T 值,并返回指向它的指针. var t *T = new(T) 或 t := new(T) 代码如下: 复制代码 代码如下: package main import "fmt" type Vertex struct {     X, Y int } func main() {     v := new(Vertex)     fmt.Println(v)     v

Python松散正则表达式用法分析

本文实例讲述了Python松散正则表达式用法.分享给大家供大家参考,具体如下: Python 允许用户利用所谓的 松散正则表达式来完成这个任务.一个松散正则表达式和一个紧凑正则表达式主要区别表现在两个方面: 1. 忽略空白符.空格符,制表符,回车符不匹配它们自身,他们根本不参与匹配.(如果你想在松散正则表达式中匹配一个空格符,你必须在它前面添加一个反斜线符号对他进行转义) 2. 忽略注释.在松散正则表达式中的注释和在普通Python代码中的一样:开始于一个#符号,结束于行尾.这种情况下,采用在一

C语言switch使用之诡异用法详解

关于switch的用法这里不再做什么总结了,其实这个是一个便捷的快速跳转条件切换器.而关于这个功能最常用的技术讨论点在于case后面的break以及default.这里不讨论这些,直接看下面的代码: #include"stdio.h" int main(void) { int num = 0; switch(num) { printf("functionrun!\n"); } return 0; } 上面的代码中用到了一个switch,但是代码块中没有任何case以