한빛출판네트워크

제공: 한빛미디어 네트워크 기사

원문: http://www.onlamp.com/pub/a/onlamp/2006/04/06/boostregex.html
저자: Ryan Stephens, 한동훈 역

텍스트를 검색하고, 파싱하는 과정은 어수선하다. 처음에는 문자열을 토큰으로 나누고, 구조를 재빨리 해석하는 간단한 문제처럼 보였던 것이 루프, if/then 문장, 버그로 이뤄진 안개같은 상태로 변하다가 종국에는 반쯤 아니 완전히 정신나간 상태까지 진행된다. 처음에는 URL에서 호스트 이름을 가져오는 것처럼 쉬운 것이 나중에는 로그 파일을 분석하고, 날짜로 된 문자열을 검사하는 것과 같은 복잡한 작업으로 발전하고, 점점 다루기 어려운 것으로 변한다.

오래 전부터 정규식은 이런 진흙탕에서 프로그래머들을 구원했다. 작지만 암호같은 정규식은 원하는 거의 모든 형식을 표현할 수 있으며, 복잡한 파싱 코드를 작성하는 임무로부터 개발자들을 구원해준다. 정규식은 강력할 뿐만 아니라, 어떤 언어에서든지 사용할 수 있으며, Perl에서는 정규식이 코드의 대부분을 차지한다. 현대 프로그래밍 언어들은 정규식에 대해 표준화된 방법으로 지원한다. 여기에는 펄, 자바, C#, 루비, 파이썬등이 있다. 슬프게도, C++은 이 목록에 없다. 정규식에 대해 유일하게 표준화된 방법은 몇 안되는 POSIX C API 함수들 뿐이다. 그렇더라도 걱정하지는 마라. 아직 C++에는 희망이 있다.

존(John Maddock)이 한시적인 표준 라이브러리로 만든  Boost.Regex 라이브러리가 이 문제를 해결해준다. 더 좋은 소식은 C++ 표준화위원회(TR1)에서 C++의 다음 표준 라이브러리의 표준 라이브러리로 Boost.Regex를 포함시키기로 했다는 점이다. 이제부터 C++에서 정규식을 사용한다면 이 라이브러리를 사용하면 된다. 이 라이브러리는 모두의 것이다.

Boost.Regex를 사용하면 간단한 매칭(전화번호 검사 같은 것)에서 검색 및 치환 같은 모든 작업을 할 수 있다. 여기서는 Boost.Regex로 할 수 있는 다음 기본 기능들을 설명할 것이다.

• 매칭
  
• 간단한 파싱
  
• 열거(Enumeration)

이 글을 모두 읽은 다음에는 Boost.Regex로 무엇을 할 것인가에 대한 좋은 아이디어만 생각하면 된다. Boost.Regex를 시작하기 전에, 정규식에 대한 간단한 소개부터 하겠다.

배경 및 정의

정규식 구문은 그 자체로 완전한 언어이며, 정규식을 이해하기 완전히 이해하려면 몇 줄의 설명으로는 어림도 없다. 따라서, 여기서는 간단한 내용만 소개할 것이며, 원한다면 정규식에 대해 보다 많은 것들을 설명하고 있는 페이지들을 참고 자료로 제공할 것이다.

정규식은 정규식 엔진이 해석하고, 대상 문자열에 적용하기 위한 문자들로 구성된 문자열이다. C++에서 정규식 엔진은 Boost.Regex에 해당한다. 엔진은 문자열에 대해 식을 평가하고, 해당 식이 대상 문자열의 일부분이라면 전체 문자열이 일치하는지, 아닌지를 확인한다. 정규식이 문자열의 일부분이라면, 불리언 표현 값이나 실제로 식을 만족하는 텍스트를 결과로 가져올 수 있다.

이 글에서는 일부러 매치(match)와 검색(search)을 특별한 의미로 사용한다. 주어진 문자열을 정규식이 매치한다고 얘기할 때는 전체 문자열이 식을 만족한다는 것을 의미한다. 예를 들어, 다음과 같은 정규식을 생각해보자.

역주: match와 search를 보통은 구별하지 않고, "검색한다"라고 얘기하지만, 저자가 match와 search를 구분하기 때문에 match는 매치로 옮겼다.

a+|b+

위 식은 a가 한 번 이상 나오거나 b가 한 번 이상 나오는 문자열을 매치한다. + 기호의 의미는 "문자가 한 번 또는 그 이상의 문자들을 매치하라"이다. 파이프 연산자(|)는 논리적으로 "또는"이라는 의미이다. 따라서, 다음과 같은 문자열은 위 정규식과 매치된다.

a
aaaaa
b
bbbb

그러나, 다음 문자열은 매치되지 않는다.

ab
aac
x

정규식 a+|b+이 의미하는 것은 의사코드로 "문자열이 a로만 되어 있고, a가 한 번 이상 나오는 경우 또는 문자열이 b로만 되어 있고, b가 한 번 이상 나오는 경우에 true를 반환하라"이다.

반대로, 문자열에서 정규식을 만족하는 하위 문자열을 찾는 경우에는 결과가 달라진다. 앞과 같은 정규식을 사용해서도 다음 문자열을 매치할 수 있다.

mxaaabfc
aabc
bbbbbxxxx

이는 대상 문자열의 하위문자열이 정규식을 만족하기 때문이다. 이 작은 차이 때문에 Boost.Regex에서 정규식을 테스트하는데 사용하는 클래스와 함수가 달라진다.
표1은 자주 쓰이는 정규식 토큰을 요약한 것이다. 테이블을 이용해서 몇 가지 예제를 제시하고, 그에 대해 살펴본 다음에 정규식이 갖는 표현력을 살펴보고, 예제 1의 코드를 복사해서 약간의 실험을 진행할 것이다. 일단, 정규식을 사용해서 텍스트를 검색하고, 파스하는 것이 쉽다는 것을 알게 되면, 이것을 사용할 수 밖에 없을 것이다.

기호      의미
c         특수문자가 아니라면 문자 c를 한 번 매치한다.
^         줄의 시작을 매치한다.
.         새 라인이 아닌 모든 문자를 매치한다
$         줄의 끝을 매치한다
|         식들의 논리 OR
()        그룹 표현
[]        문자 클래스 정의
*         0번 또는 그 이상의 매치
+         1번 또는 그 이상의 매치
?         0 또는 1번의 매치
{n}       표현식을 n번 매치
{n,}      표현식을 최소한 n번 매치
{n, m}    최소 n번에서 최대 m번까지 매치하는 식
\d        숫자
\D        숫자를 제외한 문자
\w        _을 포함한 알파벳 문자
\W        알파벳이 아닌 문자
\s        공백 문자(\t, \n, \r, \f)
\S        공백 문자가 아닌 것
\t        탭
\n        새 라인
\r        캐리지 리턴
\f        폼 피드(Form Feed)
\m        메타 문자(^, ., $, |, (), [], *, +, ?, \, or /)들을 이스케이프

나는 표준처럼 널리 쓰이는 펄 스타일의 정규 표현식을 사용하고 있다. POSIX는 표준화된 기본 문법과 확장 문법 두 가지를 정의하고 있으며, Boost.Regex는 이들 두 가지를 모두 제공하고 있지만, 여기서는 설명하지 않을 것이다. 표 1에서 나열한 것보다 더 많은 것들이 있지만, 정규표현식을 배우기에는 위의 것으로 충분하다. 펄 스타일의 정규식에 대해 보다 자세한 참고자료를 원한다면 펄의 regex 문서를 찾아보면 되며, Boost.Regex에서만 사용하는 옵션에 대해서는 부스트 문서 페이지를 읽어보면 된다. 또한 인터넷에서 "regular expression syntax"로 검색하면 많은 결과들을 찾아볼 수 있다.

이제, 이걸로 무엇을 할까? 먼저, 9자리 숫자로 되어 있는 SSN - 한국의 주민번호에 해당 -을 생각해보자. SSN은 세번째와 다섯번째 숫자 다음을 하이픈(-)으로 구분한다. 즉, XXX-XX-XXXX와 같은 형식으로 사용하며, 다음과 같은 간단한 정규식으로 이를 검증할 수 있다.

\d{3}\-\d{2}\-\d{4}

\d는 숫자를 매치하며, \d 다음의 {3}는 숫자가 연속해서 세 번 나오는 것을 의미한다. 즉, \d\d\d 대신에 사용한다. \-는 하이픈(-)을 의미한다. 하이픈은 정규식에서 메타문자로 사용하기 때문에 앞에 \을 붙여서 하이픈(-)을 찾는다. 위 식은 지금 설명한 이 규칙을 사용한 것이다. 즉, 숫자 2개, 하이픈, 숫자 4개도 같은 규칙이다.

어떤 사람의 이름이 Johnson인지, Johnston인지 찾아보고 싶다면 다음과 같이 쓸 수 있다.

Johnst{0,1}on
Johnson|Johnston
Johns(on|ton)

첫번째 예에서 {0,1}은 여기에 올 수 있는 문자의 수를 의미한다. 여기서는 문자 t가 0번 또는 한 번 올 수 있음을 의미한다. 두번째는 논리 OR 연산자를 괄호없이 사용한 것이며, 세번째는 논리 OR 연산자를 괄호와 함께 사용한 것이다.

매칭

앞에서 설명한 것처럼, 전체 문자열이 식을 만족하면 문자열이 정규식과 일치(match)한다고 한다. 예1은 정규식을 사용하는 간단한 프로그램이지만, 정규식을 만족하는 문자열이 있는지를 알려줄 수 있다. 컴파일하고 실행하면서 정규식이 동작하는 것을 살펴보고, 정규식이 무엇인지 느껴보기 바란다.

#include
#include
#include   // Boost.Regex lib

using namespace std;

int main( ) {

   std::string s, sre;
   boost::regex re;

   while(true)
   {
      cout << "Expression: ";
      cin >> sre;
      if (sre == "quit")
      {
         break;
      }
      cout << "String:     ";
      cin >> s;

      try
      {
         // Set up the regular expression for case-insensitivity
         re.assign(sre, boost::regex_constants::icase);
      }
      catch (boost::regex_error& e)
      {
         cout << sre << " is not a valid regular expression: \""
              << e.what() << "\"" << endl;
         continue;
      }
      if (boost::regex_match(s, re))
      {
         cout << re << " matches " << s << endl;
      }
   }
}

예제1. 간단한 정규식 테스트 프로그램

예제의 첫번째는 boost/regex.hpp를 포함하는 것이다. 이 헤더 파일은 Boost.Regex 라이브러리를 사용하는데 필요한 모든 것을 담고 있다. (부스트 라이브러리의 압축을 풀고, 빌드하는 것은 간단하며, 이에 대한 내용은 "부스트 시작하기"를 참고하기 바란다)

다음은 boost::regex 클래스다. 이 클래스는 정규식 그 자체를 포함하고 있다. 표준 문자열 클래스와 마찬가지로 narrow 문자와 wide 문자를 위한 클래스 템플릿((regex = basic_regex and wregex = basic_regex)을 지원한다.

regex 클래스에 정규식을 정의하기 전에는 흥미로운 것은 없다. 멤버 함수, 할당 연산자와 생성자를 해석하고, 정규식을 컴파일한다. 만약, 제대로 생성되지 않았다면 regex_error 예외를 일으킨다. assign에 대소문자 구분 무시를 의미하는 boost::regex_constants::icase를 사용했다.

마지막으로, regex_match가 모든 것을 처리한다. 여기에 사용된 매개변수는 대상 문자열과 regex 객체이다. 문자열이 표현식을 만족하면 true를 반환하고, 그렇지 않으면 false를 반환한다.

문자열을 정규식에 매칭하기 위해 Boost.Regex를 사용하는 가장 간단한 예이다. 이런 형식은 유효성 검사와 파싱에서 가장 일반적으로 사용된다.

유효성 검사

일반적으로, 사람들이 컴퓨터에 입력하는 모든 것은 의심해야하며, 검사하는 것이 필요하다. 물론, 문자 하나하나씩 비교하는 간단한 방법, if/then 구문을 이용해서 문자열의 유효성을 검사할 수 있다. 그렇지만 왜 그렇게 하는가? 보기에 지저분한 문자 하나하나씩 파싱하는 코드를 작성하느라 시간을 낭비하지말고, 코드를 간결하고, 작성하는 의도를 명확하게 할 수 있는 정규식을 사용하는 것이 낫다.

사용자가 일상적으로 잘못 입력하는 것 중에 좋은 예가 URL이다. 설정 파일이나 사용자가 입력한 위치에서 URL을 읽어들이는 응용프로그램이 있다고 해보자. 첫번째는 네트워크 라이브러리에 이 URL을 전달하기 전에 이 값이 올바른지 검증하는 것이다. 또는, 네트워크 라이브러리를 작성하고 있다면, URL을 해석하기 전에 URL의 형식이 맞는지부터 검사해야 한다. URL은 최소한 세 가지 구성요소 즉, 프로토콜, 호스트 이름, 경로로 되어 있다.

ftp://downloads.foo.com/apps/linux/patch.gz

FTP, HTTP, HTTPS 프로토콜을 사용할 수 있으며, URL을 검사하는 정규식은 다음과 같다.

(ftp|http|https):\/\/(\w+\.)*(\w*)\/([\w\d]+\/{0,1})+

괄호안의 첫번째 표현식, (ftp|http|https),은 프로토콜을 검사한다. 이 표현식은 URL에서 세 가지 프로토콜 중에 하나만 매치한다. 다음은 콜론(:)과 슬래시다. 슬래시는 제어 문자로 사용하기 때문에 여기서는 역슬래시(\)를 함께 사용해서 슬래시(/)를 표현한다. 다음은 (\w+W.)*(\w*)인데 foo.com 또는 foo와 같은 형태를 허용하는 것으로, 호스트 이름에서 문자와 숫자를 표시한다. 다음은 슬래시(/)이고, 그 다음은 ([\w\d]+\/{0,1})+이다. 이 식은 /downloads/w32/utils와 같은 형태의 경로 이름을 매치한다.

예제 1을 이용해서 다음과 같은 코드를 쉽게 작성할 수 있다.

try
{
   boost::regex re("(ftp|http|https):\/\/(\w+\.)*(\w*)\/([\w\d]+\/{0,1})+");
   if (!boost::regex_match(url, re))
   {
      throw "Your URL is not formatted correctly!";
   }
}
catch (boost::regex_error& e)
{
   cerr << "The regexp " << re << " is invalid!" << endl;
   throw(e);
}

regex_match는 문자열, char *, 이터레이터 범위, |" 표준 라이브러리 알고리즘을 처리하는 오버로딩 메서드를 갖고 있다.

앞의 코드 조각은 문법 검사를 수행한다. 문자열이 정규표현식을 만족하면, 행복할 것이다. 정규식의 길은 이걸로 끝이 아니다. 문자열의 구조를 검증하는 간단한 것 말고, 보다 복잡한 것들을 처리하는 것이 필요한 경우도 있다. 예를 들어, URL에서 호스트이름을 추출하는 것처럼, 문자열의 일부를 추출하고 그것을 처리하는 경우도 필요하다.

파싱

regex_match는 문자열이 표현식을 만족하는가의 여부만 확인하는 것 외에 문자열을 부분부분으로 나누는 것도 가능하다. match_result 객체에 결과를 저장하며, match_result는 결과를 조사하기 위해 반복(iterate)하는 시퀀스-표준 라이브러리 시퀀스를 의미-이다.

예제 2는 예제1을 수정한 버전이다. 새 버전에서는 match_result을 typedef한 cmatch를 포함하고 있다. 표준 라이브러리 문자열과 마찬가지로, Boost.Regex는 narrow 문자열과 wide 문자열을 모두 지원한다.

#include
#include
#include

using namespace std;

int main( ) {

   std::string s, sre;
   boost::regex re;
   boost::cmatch matches;

   while(true)
   {
      cout << "Expression: ";
      cin >> sre;
      if (sre == "quit")
      {
         break;
      }

      cout << "String:     ";
      cin >> s;

      try
      {
         // Assignment and construction initialize the FSM used
         // for regexp parsing
         re = sre;
      }
      catch (boost::regex_error& e)
      {
         cout << sre << " is not a valid regular expression: \""
              << e.what() << "\"" << endl;
         continue;
      }
      // if (boost::regex_match(s.begin(), s.end(), re))
      if (boost::regex_match(s.c_str(), matches, re))
      {
         // matches[0] contains the original string.  matches[n]
         // contains a sub_match object for each matching
         // subexpression
         for (int i = 1; i < matches.size(); i++)
         {
            // sub_match::first and sub_match::second are iterators that
            // refer to the first and one past the last chars of the
            // matching subexpression
            string match(matches[i].first, matches[i].second);
            cout << "\tmatches[" << i << "] = " << match << endl;
         }
      }
      else
      {
         cout << "The regexp \"" << re << "\" does not match \"" << s << "\"" << endl;
      }
   }
}

예제2. 하위포현식을 사용한 문자열 파싱

예제2에서 matches는 sub_match 객체의 시퀀스다. sub_match 클래스는 멤버 first와 second를 갖고 있다. 이들은 원래 문자열에서 첫번째와 마지막에서 하나 지난(one-past-the-last)을 가리킨다. matches[0]는 원래 문자열 전체를 담고 있으며, sub_match 객체의 인덱스 [1..n]은 원래 표현식에서 상응하는 하위 표현식을 매치한 하위 문자열 n개를 가리킨다.

하위 표현식은 괄호 안에 포함된 원래 정규식의 일부분이다. 예를 들어, 다음 정규식은 하위 정규식을 세 개 갖고 있다.

(\d{1,2})\/(\d{1,2})\/(\d{2}|\d{4})

이 정규식은 MM/DD/YY 또는 MM/DD/YYYY의 형태로 된 날짜들을 매치한다. 여기서는 값의 의미에 대해서는 검증하지 않기 때문에, 월에 해당하는 MM이 12보다 클 수도 있다. 어떻게 하면 각 부분을 잡아낼 수 있는가? 그림1이 아이디어를 설명해준다. 위 정규식을 문자열 11/5/2005에 사용하면 match_results 객체는 그림1과 같이 보게된다.


그림1. regex_match의 결과

이 날짜를 해석하고 나면, matches에는 4개의 요소를 갖게 된다. 인덱스 0의 요소는 전체 문자열을 가리키며, matches에 있는 각 요소들은 원래 문자열에서 해당하는 하위 표현식을 만족하는 요소들을 가리킨다. 전체 문자열은 정규표현식을 매치하며, 각각의 하위 표현식은 match_results 시퀀스에서 인덱스 1-3으로 이용할 수 있다.

사용하고 있는 하위 표현식의 타입에 따라, match_results의 내용이 놀라운 것일 수도 있다. 위 URL 예제를 생각해보자. 정규 표현식은 하위 표현식 네 개를 갖고 있다. 굵은 글씨로 하위 표현식을 표시했다.

(ftp|http|https):\/\/(\w+\.)*(\w*)\/([\w\d]+\/{0,1})+

하위 표현식을 반복하는 것은(예를 들어, (\w+\.)*) 하위 표현식이 몇 번이든 매치할 수 있다는 것을 의미한다. 따라서, 매치된 결과는 차례대로 match_results에 저장된다. URL 정규 표현식을 사용해서 예제 2의 예제를 실행한 결과는 다음과 같이 된다.

정규식: (ftp|http|https):\/\/(\w+\.)*(\w*)\/([\w\d]+\/{0,1})+
문자열:     http://www.foo.com/bar
        matches[0] = http://www.foo.com/bar
        matches[1] = http
        matches[2] = foo.
        matches[3] = com
        matches[4] = bar

결과에서 "www."이 빠졌다는 것을 바로 눈치챘을 지도 모른다. 하위 표현식을 반복하는 것은 마지막으로 매치된 하위 표현식만 저장하기 때문이다. 예를 들어, URL에서 전체 호스트 이름을 잡아내고 싶다면, 다음과 같이 굵은 괄호로 표시된 하위 표현식을 추가해야 한다.

(ftp|http|https):\/\/((\w+\.)*(\w*))\/([\w\d]+\/{0,1})+

이는 여러 개의 하위 표현식을 전체 호스트이름으로 묶는다. match_results 시퀀스에서 상응하는 sub_match 객체의 순서는 중첩된 하위 표현식의 트리가 깊이 우선, 왼쪽에서 오른쪽으로 탐색하는 순서로 결정된다. 수정된 정규식을 사용했을 때의 출력 결과는 다음과 같다.

표현식: (ftp|http|https):\/\/((\w+\.)*(\w*))\/([\w\d]+\/{0,1})+
문자열:     http://www.foo.com/bar
        matches[0] = http://www.foo.com/bar
        matches[1] = http
        matches[2] = www.foo.com
        matches[3] = foo.
        matches[4] = com
        matches[5] = bar

matches[2]에서 호스트 이름에 대한 하위 표현식의 매치 결과가 표시되는 것을 제외하면 이전과 동일하다.

이 기술을 사용해서 정규 표현식 구문을 연습해보면, 문자열을 검증하고, 파싱하는 작업 등에 Boost.Regex를 사용할 수 있을 것이다. 그러나, 이 예제들은 정규식의 강력한 능력의 일부분만 살펴본 것에 불과하다. 정규식에 익숙하지 않다면, 보다 많은 실험을 해보기 바란다. 아마, 정규식을 사용해서 여러분이 원하는 것을 얼마나 많이 할 수 있는지 안다면 놀랄 것이다.

검색

전체에서 하나의 문자열을 매칭하고 파싱하는 것은 원하는 문자열을 포함한 문자열을 찾아주는 검색의 문제를 해결해 주지 못한다.

매칭과 마찬가지로, Boost.Regex는 정규식을 이용해서 문자열을 검색하는 두 가지 방법을 제공한다. 가장 간단한 경우로, 주어진 문자열과 정규 표현식의 매치 여부만 알고 싶은 경우다. 예제 3은 파일에서 각 라인을 읽어서, 정규표현식과 만족하는 문자열이 있으면, 해당 라인을 출력하는 grep을 간단하게 구현한 것이다.

#include
#include
#include
#include

using namespace std;
const int BUFSIZE = 10000;

int main(int argc, char** argv) {

   // Safety checks omitted...
   boost::regex re(argv[1]);
   string file(argv[2]);
   char buf[BUFSIZE];

   ifstream in(file.c_str());
   while (!in.eof())
   {
      in.getline(buf, BUFSIZE-1);
      if (boost::regex_search(buf, re))
      {
         cout << buf << endl;
      }
   }
}

예제3 간단한 grep

regex_match를 사용한 방법과 같이 regex_search를 사용할 수 있다.

주어진 패턴을 매치하는 모든 하위 문자열을 열거할 수도 있다. 예를 들어, 웹 크롤러를 작성하고 있고, 페이지 내에 사용된 모든 A 태그에 대해 반복하고 싶다고 해보자. A 태그를 잡아내기 위해 다음과 같은 정규 표현식을 사용할 수 있다.



grep 예제처럼 전체 라인을 반환하는 대신, 대상 URL만 필요하기 때문에 match_results에서 두번째 하위 표현식을 사용한다. 예제 4는 예제 3을 살짝 고친것이다.

#include
#include
#include
#include

using namespace std;
const int BUFSIZE = 10000;

int main(int argc, char** argv) {

   // Safety checks omitted...
   boost::regex re("");
   string file(argv[1]);
   char buf[BUFSIZE];
   boost::cmatch matches;
   string sbuf;
   string::const_iterator begin;
   ifstream in(file.c_str());

   while (!in.eof())
   {
      in.getline(buf, BUFSIZE-1);
      sbuf = buf;
      begin = sbuf.begin();

      while (boost::regex_search(begin, sbuf.end(), matches, re))
      {
         string url(matches[1].first, matches[1].second);
         cout << "URL: " << url << endl;
         // Update the beginning of the range to the character
         // following the match
         begin = matches[1].second;
      }
   }
}

예제4. A 태그를 사용하여 반복하기

예제 4에 작성된 정규표현식은 역슬래시를 많이 사용하고 있다. 특정 문자를 두 번 이스케이프하기 위해 필요하다. 한번은 컴파일러를 위해서, 다른 한 번은 정규 표현식 엔진을 위해서 이스케이프한 것이다.

예제 4는 예제3에서 사용한 것과 다른 regex_search 메서드를 사용한다. 이 버전은 검색된 문자들의 범위의 시작과 끝을 나타내는 양방향 이터레이터 인자를 두 개 사용한다. 매칭되는 하위 문자열에 접근하기 위해 matches[1].second가 나타내는 마지막 매치 다음에 문자를 시작지점을 나타내게 업데이트하는 한다.

이것이 일치한 패턴을 모두 나열하는 유일한 방법은 아니다. 이터레이터를 이용하는 쪽을 선호한다면 정규표현식 검색에서 결과에 대한 이터레이터 인퍼테이스를 제공하는 regex_token_iterator를 사용할 수 있다. 예제 4에서 URL 검색 결과에 대해 반복하는 부분을 다음과 같이 고칠 수 있다.

   // Read the HTML file into the string s...
   boost::sregex_token_iterator p(s.begin(), s.end(), re, 0);
   boost::sregex_token_iterator end;

   for (;p != end;count++, ++p)
   {
      string m(p->first, p->second);
      cout << m << endl;
   }

이게 전부는 아니다. 첫번째 토큰 이터레이터는 생성자의 마지막 인자로 0을 전달한다. 이는 정규 표현식을 만족하는 문자열에 대해 반복하라는 의미다. 이 값을 -1로 하면, 정규식을 만족하지 않는 하위 문자열에 대해 반복하라는 의미가 된다. 다시 말해서, 문자열을 토큰으로 나눈다. 각 토큰은 정규 표현식을 만족하는 것이 된다. 이를 사용하면 복잡한 구분자로 되어 있는 문자열을 원하는 토큰으로 나눌 수 있게 해준다. 예를 들어, 웹 페이지를 파싱하는 복잡한 경우에도 문서를 각 영역별로 나눌 수 있다.

확인할 것

여기서 설명한 것보다 Boost.Regex는 더 많은 것들을 제공한다. Boost.Regex 페이지의 문서는 많은 예제들을 제공하고 있으며, 위에서 설명한 문자열 검색외에 다음과 같은 것들도 할 수 있다.

• 펄과 Sed 스타일의 형식 변환을 사용하는 검색과 치환
  
• POSIX 기본 정규표현식과 확장 정규 표현식의 사용
  
• 유니코드 문자열과 비표준 문자열 형식의 사용

정규표현식을 실험해보기 바란다. 같은 일을 하는 다양한 방법들이 존재하며, 원하는 것을 하는 정규식을 간결하게 만들 수 있는 방법이 없는지 확인해봐야 한다.

결론

Boost.Regex는 C++에서 정규표현식 엔진을 구현하는 라이브러리다. 복잡하고, 번거로운 문자열 파싱 코드를 작성하는 대신, 이 라이브러리를 사용해서 문자열에 정규표현식을 사용해서 매치, 검색, 또는 검색 & 치환을 할 수 있다. Boost.Regex는 다음 버전의 C++ 표준 라이브러리로 승인되었으며, TR1의 구현(tr1 네임스페이스)에서 이것을 보게 될 것이다.

Ryan Stephens은 애리조나 템페에 살고 있는 소프트웨어 엔지니어, 라이터, 학생이다. 그는 모든 언어로 프로그래밍하는 것, 특히 C++로 프로그래밍하는 것을 즐긴다.