C语言POSIX正则表达式示例

最新推荐文章于 2021-03-29 20:14:06 发布
最新推荐文章于 2021-03-29 20:14:06 发布
阅读量1.2k 收藏
点赞数
分类专栏： C/C++高级用法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gubenpeiyuan/article/details/8467431
版权


C语言的正则表达式具有效率高，编程容易的特点，其精华在于写出一个好的正则表达式规则。

示例如下。规则可以看我的其他博文。

下面是示例调试的时候，可以发现，其实有些问题，不能置零字符串尾，否则否内存错误。很奇怪，这是C的内存操作的奥秘啊。

#include <sys/types.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char ** argv)
{
	// !AIVDM,\.{20,80}\,.[*]    ^(hisencyber)(.com|.com.cn)
	// \{m,n\}   "!AIVDM,\..*\,0*"  "!AIVDM,\.*\,0*"   REG_NOSUB  child char check
    char * pRegexStr = (char *)"!AIVDM,\.{1,72}\[*]";
    char * pText_ =
	"!AIVDM,2,1,3,A,577K2:02;M1AI9HkP01DpUHE9<4j0lfo;33P000`40=664000422isC@,0*2F\
	!AIVDM,2,2,3,A,@h0000000000000,2*0F\
	!AIVDM,1,1,,B,9002=mQq1oIJvt6;2eUn>Sh0040<,0*5D\
	!AIVDM,1,1,,A,>5?Per18=HB1U:1@E=B0m<L,2*51\
	!AIVDM,1,1,,B,C5N3SRP0IFJKmE4:v6pBGw`@62PaLELTBJ:V00000000S0D:R220,0*3A\
	!AIVDM,2,1,5,B,E1mg=5J1T4W0h97aRh6ba84<h2d;W:Te=eLvH50```q,0*46\
	!AIVDM,2,2,5,B,:D44QDlp0C1DU00,2*36\
	!AIVDM,1,1,,B,15Mq4J0P01EREODRv4@74gv00HRq,0*88\
	!AIVDM,1,1,,A,;4eG>3iuaFP2:r3OiBH7;8i00000,0*65\
	!AIVDM,1,1,,A,B5N3SRP0FFJFC`4:CQDFKwiP200>,0*75\
	!AIVDM,1,1,,B,H5NHcTP<51@4TrM>10584@U<D000,2*77 ";

    regex_t oRegex;

    regmatch_t pmatch;
    char *msg;

    int nErrCode = 0 ; int len ; int start ;int end ;
    char szErrMsg[1024] = {0};
    size_t unErrMsgLen = 0;

    char * pText = pText_ ;
    if ((nErrCode = regcomp(&oRegex, pRegexStr,REG_EXTENDED)) == 0)
    {
        while(regexec(&oRegex, pText, 1, &pmatch,0)==0)
        {
        	len = pmatch.rm_eo-pmatch.rm_so+2 ;
        	start = pmatch.rm_so ;end =pmatch.rm_eo+2;
			msg=(char*)malloc((len)*(sizeof(char)));
			memcpy(msg,&pText[start],len);
			msg[(end)]=(char)NULL ;
			printf("%s \n",msg);
			pText = &pText[end+1] ;
        }


        regfree(&oRegex);
    }

    unErrMsgLen = regerror(nErrCode, &oRegex, szErrMsg, sizeof(szErrMsg));
    unErrMsgLen = unErrMsgLen < sizeof(szErrMsg) ? unErrMsgLen : sizeof(szErrMsg) - 1;
    szErrMsg[unErrMsgLen] = '\0';
    printf("ErrMsg: %s\n", szErrMsg);

    regfree(&oRegex);
    return 1;
}

将之作一个链表的数据结构组包，增强程序的耦合性。

数据结构的示例可以看博文：http://blog.csdn.net/luopeiyuan1990/article/details/8255632

void Regex_MSG(pRet_Regex pret_regex,char *Regex_rule,char *pText_)
{
	pRet_Regex pret_regex_ = pret_regex ;
	char *pRegexStr = Regex_rule ;
	char * pText = pText_ ;

	regex_t oRegex;
	regmatch_t pmatch;

	int nErrCode = 0 ; int len ; int start ;int end ;
	char szErrMsg[1024] = {0};
	size_t unErrMsgLen = 0;

	if ((nErrCode = regcomp(&oRegex, pRegexStr,REG_EXTENDED)) == 0)
	{
		while(regexec(&oRegex, pText, 1, &pmatch,0)==0)
		{
			pRet_Regex pNode =Before_Null_Node(pret_regex);

			//pRet_Regex pNode = CreateNode();
			AddNode(pNode,pNode->next);

			len = pmatch.rm_eo-pmatch.rm_so+2 ;
			start = pmatch.rm_so ;end =pmatch.rm_eo+2;

			pNode->next->Data=(char*)malloc((len)*(sizeof(char)));
			memcpy(pNode->next->Data,&pText[start],len);
			pNode->next->Data[(end)]=(char)NULL ;
			//printf("%s \n",pNode->next->Data);
			pText = &pText[end+1] ;
		}
		regfree(&oRegex);
		PrintList(pret_regex);
	}

	unErrMsgLen = regerror(nErrCode, &oRegex, szErrMsg, sizeof(szErrMsg));
	unErrMsgLen = unErrMsgLen < sizeof(szErrMsg) ? unErrMsgLen : sizeof(szErrMsg) - 1;
	szErrMsg[unErrMsgLen] = '\0';
	printf("ErrMsg: %s\n", szErrMsg);

	regfree(&oRegex);
}


最后分拆为两个文件：

#include <sys/types.h>

#include "Eregex.hpp"


int main(int argc, char ** argv)
{
	// !AIVDM,\.{20,80}\,.[*]    ^(hisencyber)(.com|.com.cn)
	// \{m,n\}   "!AIVDM,\..*\,0*"  "!AIVDM,\.*\,0*"   REG_NOSUB  child char check
    //char * pRegexStr = (char *)"!AIVDM,\.{1,72}\[*]";
    char * pText_ =
	(char*)"!AIVDM,2,1,3,A,577K2:02;M1AI9HkP01DpUHE9<4j0lfo;33P000`40=664000422isC@,0*2F\
	!AIVDM,2,2,3,A,@h0000000000000,2*0F\
	!AIVDM,1,1,,B,9002=mQq1oIJvt6;2eUn>Sh0040<,0*5D\
	!AIVDM,1,1,,A,>5?Per18=HB1U:1@E=B0m<L,2*51\
	!AIVDM,1,1,,B,C5N3SRP0IFJKmE4:v6pBGw`@62PaLELTBJ:V00000000S0D:R220,0*3A\
	!AIVDM,2,1,5,B,E1mg=5J1T4W0h97aRh6ba84<h2d;W:Te=eLvH50```q,0*46\
	!AIVDM,2,2,5,B,:D44QDlp0C1DU00,2*36\
	!AIVDM,1,1,,B,15Mq4J0P01EREODRv4@74gv00HRq,0*88\
	!AIVDM,1,1,,A,;4eG>3iuaFP2:r3OiBH7;8i00000,0*65\
	!AIVDM,1,1,,A,B5N3SRP0FFJFC`4:CQDFKwiP200>,0*75\
	!AIVDM,1,1,,B,H5NHcTP<51@4TrM>10584@U<D000,2*77 ";

	pRet_Regex pret_regex;
	pret_regex = (pRet_Regex)malloc(sizeof(Ret_Regex)); pret_regex->next =NULL;
	//!AIVDM,\.{1,72}\[*]
	Regex_MSG(NULL,(char*)"!AIVDM,\.*\[*]",pText_);
}

另外一个是hpp文件，但是使用的时候最好写到c文件中 

#include <stdio.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Ret_Regex
{
	char *Data;
	unsigned char length;
	Ret_Regex *next;
}Ret_Regex,*pRet_Regex ;

#define Linkpointer pRet_Regex
#define LinkEntity Ret_Regex


void Entity_entity(Linkpointer Node)
{
	//Node->Data = readyplaindata.length ;
	//Node->Data = readyplaindata.Data ;
}
/* first is messy print */
void Entity_print(Linkpointer Node)
{
	printf("%s \n",Node->Data);
}
void PrintList(Linkpointer phead)
{
	Linkpointer p = phead ;
	while(p!=NULL)
	{
		Entity_print(p);
		p = p->next ;
	}
}
/* Length 1 no data only head */
int GetLength(Linkpointer phead)
{
	Linkpointer p = phead ; int Length=0 ;
	while(p!=NULL)
	{
		Length ++ ;
		p = p->next ;
	}
	return Length ;
}
Linkpointer Before_Null_Node(Linkpointer phead)
{
	Linkpointer p = phead ;
	while(p->next!=NULL)
	{
		p=p->next ;
	}
	return p ;
}
/* Create,return Node add */
Linkpointer CreateNode()
{
	Linkpointer pNode = (Linkpointer)malloc(sizeof(LinkEntity));
	if(pNode==NULL)
	{
		printf("Node malloc error \n");
	}
	Entity_entity(pNode);
	pNode->next = NULL ;
	return pNode ;
}
/* Add Node between */
void AddNode(Linkpointer pNode,Linkpointer pNode2)
{
	Linkpointer pNew = CreateNode();
	pNode->next = pNew ;
	pNew->next = pNode2 ;
}
/* Delete next Node */
bool DeleteNode(Linkpointer pNode)
{
	Linkpointer pDel = pNode->next ;
	if(pDel==NULL)
	{
		printf(" No Node to Delete ");
		return 0 ;
	}
	pNode->next = pDel->next ;

	pDel->next = NULL ;
	free(pDel);
	return 1 ;
}
/**************************************************************
 *  Two Mode
 *  1. find str meets Regex_rule , fill it into linklist
 *  (linklist must initialis first)
 *  (Head of pText will change)
 *  2. find first str meets Regex_rule , return it
 *  (Head of pText will change)
 *  pText is not freed , free yourself.
 *
 ***************************************************************/
char* Regex_MSG(pRet_Regex pret_regex_,char *Regex_rule,char *pText_)
{
	pRet_Regex pret_regex = pret_regex_ ;
	char *pRegexStr = Regex_rule ;
	char * pText = pText_ ;

	regex_t oRegex;
	regmatch_t pmatch;

	int nErrCode = 0 ; int len ; int start ;int end ;
	char szErrMsg[1024] = {0};
	size_t unErrMsgLen = 0;

	if(pret_regex!=NULL)
	{
		if ((nErrCode = regcomp(&oRegex, pRegexStr,REG_EXTENDED)) == 0)
		{
			while(regexec(&oRegex, pText, 1, &pmatch,0)==0)
			{
				pRet_Regex pNode =Before_Null_Node(pret_regex);

				//pRet_Regex pNode = CreateNode();
				AddNode(pNode,pNode->next);

				len = pmatch.rm_eo-pmatch.rm_so+2 ;
				start = pmatch.rm_so ;end =pmatch.rm_eo+2;

				pNode->next->Data=(char*)malloc((len)*(sizeof(char)));
				memcpy(pNode->next->Data,&pText[start],len);
				pNode->next->Data[(end)]=(char)NULL ;
				//printf("%s \n",pNode->next->Data);
				pText = &pText[end+1] ;
			}
			regfree(&oRegex);
			PrintList(pret_regex);
		}
	}
	else{
		char *OutChar ;
		if ((nErrCode = regcomp(&oRegex, pRegexStr,REG_EXTENDED)) == 0)
		{
			while(regexec(&oRegex, pText, 1, &pmatch,0)==0)
			{
				len = pmatch.rm_eo-pmatch.rm_so+2 ;
				start = pmatch.rm_so ;end =pmatch.rm_eo+2;

				OutChar=(char*)malloc((len)*(sizeof(char)));
				memcpy(OutChar,&pText[start],len);
				OutChar[(end)]=(char)NULL ;
				printf("Out char is %s \n",OutChar);
				pText = &pText[end+1] ;
				return OutChar ;
			}
		}
	}

	unErrMsgLen = regerror(nErrCode, &oRegex, szErrMsg, sizeof(szErrMsg));
	unErrMsgLen = unErrMsgLen < sizeof(szErrMsg) ? unErrMsgLen : sizeof(szErrMsg) - 1;
	szErrMsg[unErrMsgLen] = '\0';
	printf("ErrMsg: %s\n", szErrMsg);

	regfree(&oRegex);
	return NULL ;
}


bug修改如下：


char* Regex_MSG(pRet_Regex pret_regex_,char *Regex_rule,char *pText_,pTAisRawData pAisRawData_,int FrontShifting,int BackShifting)
{
    pRet_Regex pret_regex = pret_regex_ ;
    pTAisRawData p = pAisRawData_ ;
    char *pRegexStr = Regex_rule ;
    char * pText = pText_ ;
    char *OutChar ;

    regex_t oRegex;
    regmatch_t pmatch;

    int nErrCode = 0 ; int len ; int start ;int end ;
    char szErrMsg[1024] = {0};
    size_t unErrMsgLen = 0;

    if(pret_regex!=NULL)
    {
        if ((nErrCode = regcomp(&oRegex, pRegexStr,REG_EXTENDED)) == 0)
        {
            while(regexec(&oRegex, pText, 1, &pmatch,0)==0)
            {
                pRet_Regex pNode =Ret_Regex_Before_Null_Node(pret_regex);

                //pRet_Regex pNode = CreateNode();
                Ret_Regex_AddNode(pNode,pNode->next);

                len = pmatch.rm_eo-pmatch.rm_so+BackShifting ;
                start = pmatch.rm_so +FrontShifting;
                end =pmatch.rm_eo+BackShifting;

                pNode->next->Data=(char*)malloc((len)*(sizeof(char)));
                memcpy(pNode->next->Data,&pText[start],len);
                //pNode->next->Data[(end)]=(char)NULL ;
                //printf("%s \n",pNode->next->Data);
                pText = &pText[end] ;
            }
            Ret_Regex_PrintList(pret_regex);
        }
    }
    else{

        if ((nErrCode = regcomp(&oRegex, pRegexStr,REG_EXTENDED)) == 0)
        {
            while(regexec(&oRegex, pText, 1, &pmatch,0)==0)
            {
                len = pmatch.rm_eo-pmatch.rm_so+BackShifting ;
                start = pmatch.rm_so +FrontShifting;end =pmatch.rm_eo+FrontShifting;

                OutChar=(char*)malloc((len)*(sizeof(char)));
                memcpy(OutChar,&pText[start],len);
                //OutChar[(end)]=(char)NULL ;
                printf("Out char is %s \n",OutChar);
                pText = &pText[end] ;

            }
            if(p!=NULL)
            {
                free(p->Data);
                p->Data=strdup(pText);
            }
        }
    }

    unErrMsgLen = regerror(nErrCode, &oRegex, szErrMsg, sizeof(szErrMsg));
    unErrMsgLen = unErrMsgLen < sizeof(szErrMsg) ? unErrMsgLen : sizeof(szErrMsg) - 1;
    szErrMsg[unErrMsgLen] = '\0';
    printf("ErrMsg: %s\n", szErrMsg);

    regfree(&oRegex);
    return OutChar ;
}

















放牛娃不吃草
关注
专栏目录
正则表达式学习笔记之POSIX
Code_Thinking的专栏
09-06 1879
POSIX规范          正则表达式liangdaliupai
POSIX正则表达式
weixin_30299709的博客
10-14 129
POSIX正则表达式规范 参考：http://en.wikipedia.org/wiki/Regular_expression 　　POSIX正则表达式分为Basic Regular Expressions 和 Extended Regular Expressions。 　　ERE增加支持?,+和|，去除了通配符()和{}。而且POSIX正则表达式的标准语法经常坚持使用附加的语法来支持特殊应...
正则表达式教程 C语言POSIX
固本培元的专栏
12-28 1313
原文转载自：http://www.wuzesheng.com/?p=929 深入浅出C/C++中的正则表达式库(一)——GNU Regex Library 2010年4月1日小武哥发表评论阅读评论 写在前面: 本文是面向有正则表达式基础的读者朋友的，如果你还不知道正则表达式是什么，请先到这里学习一下 ：http://en.wikipedia.org/wik
25. 正则表达式POSIX字符
我思故我在！
03-29 160
C语言POSIX线程常用函数
一路走来@嵌入式
08-27 1089
<br />#include <pthread.h><br />1. int pthread_create(pthread_t *thread,pthread_attr_t *attr,void *(*start_routine)(void *),void *arg); //创建新线程<br />2. void pthread_exit(void *retval)； //终止线程<br />3. int pthread_join(pthread_t th,void **thread_return);
C语言中的正则表达式使用示例详解
08-25
C语言中的正则表达式使用示例详解 正则表达式是使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在C语言中，正则表达式的使用可以分为三步：编译正则表达式、匹配正则表达式和释放正则表达式。 编译...
C语言中的正则表达式：深入解析与实践指南
最新发布
09-04
虽然C语言标准库不直接支持正则表达式，但通过POSIX正则表达式库，我们可以在C程序中实现强大的文本匹配和处理功能。本文详细介绍了如何在C语言中使用正则表达式，包括正则表达式的基本概念、如何在C程序中使用regex...
C语言实现正则表达式匹配步骤与函数解析
"C语言中的正则表达式使用方法通过示例进行讲解，包括regcomp、regexec和regfree等函数的使用，以及正则表达式的编译、匹配和释放过程。" 在C语言中，正则表达式是用于文本处理和模式匹配的重要工具，它允许程序员...
c语言 解析正则表达式
05-19
2. POSIX正则表达式库：这是一个基于POSIX标准的正则表达式库，也可以在C程序中使用。 3. TRE（Tab Regular Expressions）：这是一个高效的正则表达式库，支持POSIX扩展正则表达式语法。它具有快速匹配速度和低内存...
c语言正则表达式dfa
08-30
在C语言中，常用的正则表达式库是PCRE（Perl Compatible Regular Expressions）库和POSIX正则表达式库。 PCRE库是一个功能强大的正则表达式库，提供了广泛的正则表达式功能。它支持Perl兼容的语法，并提供了多种...
实现posix消息队列示例分享
09-04
主要介绍了实现posix消息队列示例，学习记录锁，线程互斥量，线程条件变量，内存映射，信号，线程的综合应用,需要的朋友可以参考下
linux下的C语言POSIX正则表达式头文件和源文件： regex.h regex.cpp
12-13
linux下posix标准的正则表达式库，支持regcomp, regexec等，可以放到vs2010或vs2012下进行编译。
[c++] c语言并发编程——POSIX
LumenWang
03-25 2208
先来看以下关于c语言的几个问题 2.1 void* C语言中void * 为 “不确定类型指针”，void *可以用来声明指针。如：void * a； （1）void *可以接受任何类型的赋值： 　　　　void *a = NULL； 　　　　int * b = NULL； 　　　　a = b；//a是void * 型指针，任何类型的指针都可以直接赋值给它，无需进行强制类型转换 （2）vo...
linux C正则表达式——POSIX正则测试
DreamFlyingFish的专栏
04-29 7238
这是C的原程序#include #include int main(int argc, char** argv){ regex_t reg; regmatch_t pm[10]; char *pattern; char buf[50]; const size_t nmatch = 10; pattern = argv[1]; int
POSIX正则表达式C语言接口文档
Jeff_Dean的博客
07-19 668
POSIX为处理正则表达式提供了一系列的函数，本文档就是针对这些函数接口进行分析，以彻底掌握并达到熟练运用的目的。
正则表达式
折耳根的羹
10-18 185
一、定义： 正则表达式是一种字符串操作的语法规则，利用此语法规则可以灵活的实现字符串的匹配、拆分、替换。 示例：要求判断某一个字符串是否有数字组成。 示例：要求判断某一个字符串是否有数字组成。 常规方法： public static Boolean isNumber(String str){      if("".endsWith(str)||null==st
C语言正则表达式
热门推荐
woods2001的专栏
08-28 1万+
<br />在很多人看来，正则表达式看上去古怪且复杂，因此往往不想去触及或使用。如果我们抛开这种“畏难”心理，在经过循序渐进地学习之后，就会发现这些复杂的表达式其实写起来还是相当简单的。一旦它被你所“驯服”，就可利用正则表达式把原需数小时辛苦且易错的文本处理工作压缩在几分钟（甚至几秒钟）内完成。 <br /> <br />正则表达式定义<br />正则表达式(regular expression)是Linux系统中一种非常重要的字符串搜索模式，是一组规则字符的集合。这些规则字符能够组成我们所需要的搜索规则
ANSI C 和 POSIX介绍
For better 的专栏
02-14 7209
标准 (ANSI C, POSIX, SVID, XPG, ...) ANSI C：这一标准是 ANSI（美国国家标准局）于 1989 年制定的 C 语言标准。 后来被 ISO（国际标准化组织）接受为标准，因此也称为 ISO C。 ANSI C 的目标是为各种操作系统上的 C 程序提供可移植性保证，而不仅仅限于 UNIX。 该标准不仅定义了 C 编程语言的语发和语义，而且还定义了一个标准库
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值