Posix 정규 표현 식 API 설명

파일 1 개
#include 

2 기본 방법
2.1 regcomp
  • 함수 원형 int regcomp (regex t * preg, const char * regex, int cflags);
  • 정규 표현 식 을 컴 파일 하여 regexec 방법 으로 사용 할 수 있 도록 합 니 다
  • 매개 변수 의미
  • pregpreg 는 컴 파일 된 정규 표현 식 구 조 를 가리 키 는 지침 입 니 다. p 는 pointer, reg 는 regext 타 입.regex_t 는 컴 파일 된 정규 표현 식 을 저장 하 는 구조 체 데이터 형식 입 니 다. 구성원 rensub 는 정규 표현 식 의 하위 정규 표현 식 의 개 수 를 저장 하 는 데 사용 되 며, 하위 정규 표현 식 은 괄호 로 싸 인 부분 표현 식 입 니 다.
  • regex 는 정규 표현 식 의 문자열 을 설명 합 니 다.
  • cflags 는 컴 파일 형식 을 결정 합 니 다.선택 가능 한 값:
    값.
    설명 하 다.
    REG_EXTENDED
    확장 정규 표현 식, 설정 하지 않 으 면 기본 정규 표현 식
    REG_ICASE
    대소 문자 구분 없 음
    REG_NOSUB
    일치 하 는 결 과 를 저장 하지 않 습 니 다.이 플래그 위 치 를 설정 하면 regexec 에 서 는 nmatch 와 pmatch 두 개의 인 자 를 무시 합 니 다.
    REG_NEWLINE
    줄 바 꿈 자 를 식별 하 다.

  • 반환 값
    반환 값
    설명 하 다.
    0
    성공 하 다.
    기타 오류 코드
    실패 하 다.

  • 2.2 regexec
  • 함수 원형
    int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
  • 기능 은 컴 파일 된 정규 표현 식 에 따라 문자열 을 일치 시 킵 니 다
  • 매개 변수 의미
  • preg 가 regcomp 를 통 해 컴 파일 된 정규 표현 식 입 니 다.
  • string 이 일치 하 는 문자열 입 니 다.
  • nmatch 에 일치 하 는 문자열 의 개수 입 니 다.
  • pmatch 가 일치 하 는 배열 입 니 다.
  • eflags 가 일치 하 는 표지 입 니 다. 선택 할 수 있 는 값 은:
    값.
    설명 하 다.
    REG_NOTBOL
    regcomp 컴 파일 시 cflag 설정 REG 를 제외 하고 줄 의 시작 과 일치 하지 않 습 니 다.NEWLINE
    REG_NOTEOL
    regcomp 컴 파일 시 cflag 에 REG 를 설정 하지 않 는 한 줄 의 끝 이 일치 하지 않 습 니 다.NEWLINE

  • 반환 값
    반환 값
    설명 하 다.
    0
    성공 하 다.
    REG_NOTMATCH
    실패 하 다.

  • 2.3 구조 체 regmatcht
    regmatch_t 의 정 의 는 다음 과 같다.
    typedef struct {
          regoff_t  rm_so;
          regoff_t  rm_eo;
          } regmatch_t;

    그 중:
    하면, 만약, 만약...so, 일치 하지 않 음 을 표시 합 니 다.
    하면, 만약, 만약...rm_so, string 의 다음 최대 하위 문자열 의 오프셋 을 표시 합 니 다.
    rm_o 는 하위 문자열 의 길 이 를 표시 합 니 다.
    2.4 regerror
  • 함수 원형
    size_t regerror(int errcode, const regex_t *preg, char * errbuf, size_t errbuf_size);
  • 기능 은 regcomp 와 regexec 가 되 돌아 오 는 errorcode 를 오류 메시지 로 변환 합 니 다
  • 매개 변수 의미
  • errorcode 오류 코드 는 regcomp 또는 regexec 에서 얻 을 수 있 습 니 다.
  • preg 가 regcomp 를 통 해 컴 파일 된 정규 표현 식 입 니 다.
  • errbuf 에 잘못된 정 보 를 저장 하 는 buffer.
  • errbuf_sizeerrbuf 의 크기 입 니 다.

  • 반환 값 은 errbuf 가 오류 정 보 를 저장 하 는 데 필요 한 크기 를 되 돌려 줍 니 다.
    오류 코드
    약자 설명
    잘못된 설명
    REG_BADBR
    BR=back reference
    되 돌아 오 는 인용 조작 자 를 불법 으로 사용 하 다.
    REG_BADPAT
    PAT=pattern
    그룹 과 list 와 같은 정규 표현 식 조작 자 를 불법 으로 사용 합 니 다.
    REG_BADRPT
    RPT=repetition
    첫 번 째 문자 에서 '*' 를 사용 하 는 등 중복 되 는 조작 자 를 불법 으로 사용 합 니 다.
    REG_EBRACE
    EBRACE=error brace
    대괄호 가 일치 하지 않 음
    REG_EBRACK
    EBRACK=error bracket
    중 괄호 가 일치 하지 않 음
    REG_ECOLLATE
    ECOLLATE=error collate
    불법 매개 변수
    REG_ECTYPE
    ECTYPE=error character type
    잘못된 문자 형식
    REG_EEND
    EEND=error end
    구체 적 인 오류 가 없습니다.이 오류 코드 는 POSIX. 2 에서 정의 되 지 않 았 습 니 다.
    REG_EESCAPE
    EESCAPE=error escape
    여분
    REG_EPAREN
    EPAREN=error parenthesis
    괄호 가 일치 하지 않 음
    REG_ERANGE
    ERANGE=error range
    불법 사용 범위 조작 자, 예 를 들 어 끝 난 표 지 는 표 지 를 시작 하기 전에 나타난다.
    REG_ESIZE
    ESIZE=error size
    정규 표현 식 을 컴 파일 하 는 데 필요 한 메모리 가 64kb 이상 이 고 POSIX. 2 에 정의 되 지 않 았 습 니 다.
    REG_ESPACE
    ESPACE=error space
    정규 표현 식 컴 파일 이 메모리 공간 을 초과 하 였 습 니 다.
    REG_ESUBREG
    ESUBREG=error reference to a subexpression
    하위 표현 식 인용 불법 사용

  • 2.5 regfree
  • 함수 원형
    void regfree(regex_t *preg);
  • regcomp 에서 preg 를 컴 파일 한 메모리 방출
  • 매개 변수 의 미 는 regcomp 를 통 해 컴 파일 된 정규 표현 식
  • 반환 값 void
  • 3 C + + 의 간단 한 패키지
    C + + 를 사용 하여 간단 한 패 키 징 을 하여 더 잘 사용 할 수 있 습 니 다.
    // cregex.h
    #include 
    #include 
    #include 
    using std::string;
    using std::vector;
    
    class CStringMatch;             //      
    
    class CRegex
    {
    public:
        CRegex(const string& sPattern,int cflags=REG_EXTENDED);
        virtual ~CRegex();
        string GetErrMsg();
        CStringMatch Match(const string& sStr,int cflags=0);
        bool init(const string& sPattern,int cflags=REG_EXTENDED);
        operator bool() const {return m_isValid;}
    private:
        regex_t m_regex;
        int m_cflags;
        bool m_isValid;
        int m_errcode;
        bool isRegMatchUsed(const regmatch_t& sRegMatch);
    };
    
    class CStringMatch
    {
    public:
        CStringMatch(const string& str):m_sStr(str){
        }
        virtual ~CStringMatch(){};
        string GetMatchContent(unsigned int index){
            return string(m_sStr.c_str()+m_vMatchPlaces[index].rm_so,
                          m_sStr.c_str()+m_vMatchPlaces[index].rm_eo);
        }
        regmatch_t GetMatchPlace(unsigned int index){
            return m_vMatchPlaces.at(index);
        }
        operator bool() const {return m_isValid;}
    private:
        string m_sStr;
        friend CStringMatch CRegex::Match(const string& sStr,int cflags);
        bool m_isValid;
        vector m_vMatchPlaces;
    };
    // cregex.cpp
    #include "cregex.h"
    CRegex::CRegex(const string& sPattern,int cflags)
    {
        init(sPattern,cflags);
    }
    bool CRegex::init(const string& sPattern,int cflags)
    {
        memset(&m_regex,'\0',sizeof(m_regex));
        m_errcode = regcomp(&m_regex,sPattern.c_str(),cflags);
        if(m_errcode != 0)
        {
            m_isValid = false;
        }
        m_isValid = true;
        return m_isValid;
    }
    CRegex::~CRegex()
    {
        regfree(&m_regex);
    }
    string CRegex::GetErrMsg()
    {
        char szErrMsg[1024+1] = "";
        regerror(m_errcode, &m_regex, szErrMsg, sizeof(szErrMsg));
        return szErrMsg;
    }
    CStringMatch CRegex::Match(const string& sStr,int cflags)
    {
        const unsigned int iMax = 20;
        regmatch_t pResults[iMax];
        memset(pResults,'\0',sizeof(pResults));
        CStringMatch cMatchResult(sStr);
        m_errcode = regexec(&m_regex,sStr.c_str(),iMax,pResults,cflags);
        if(m_errcode == 0)
        {
            cMatchResult.m_isValid = true;
            unsigned int i = 0;
            for (i = 0; i  
      


    , CRegex , match , CStringMatch , CStringMatch GetMatchContent

    :

    CRegex cRegex("(.*) (.+) / ([^ ]+(       |      | | ))(.*)");
    if(cRegex)
    {    CStringMatch cMatches = cRegex.Match(sBankName);
        if(cMatches)
        {
            sBankNameElements.province = cMatches.GetMatchContent(1);
            sBankNameElements.city = cMatches.GetMatchContent(2);
            sBankNameElements.bank=cMatches.GetMatchContent(3);
            sBankNameElements.keywords=cMatches.GetMatchContent(5);
            DEBUG_LOG("province=[%s],city=[%s],bank=[%s],keywords=[%s]",sBankNameElements.province.c_str(),sBankNameElements.city.c_str(),sBankNameElements.bank.c_str(),sBankNameElements.keywords.c_str());
            return true;
        }
        else
        {
            Trace(L_DEBUG, __FILE__, __LINE__, NULL, cRegex.GetErrMsg().c_str());
        }
    }else{
        Trace(L_DEBUG, __FILE__, __LINE__, NULL, cRegex.GetErrMsg().c_str());
    }

    좋은 웹페이지 즐겨찾기