C++ Regex Iterator | "정규식 반복자" 가이드

· 14분 읽기 · 수정 중급 튜토리얼
C++ Regex Iterator | "정규식 반복자" 가이드

이 글의 핵심

C++ Regex Iterator에 대한 실전 가이드입니다.

regex_iterator란?

모든 매치 순회 (C++11)

#include <regex>

std::string text = "C++ 11, C++ 14, C++ 17";
std::regex pattern{R"(\d+)"};

auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
auto end = std::sregex_iterator();

for (auto it = begin; it != end; ++it) {
    std::cout << it->str() << std::endl;
}
// 11
// 14
// 17

기본 사용

#include <regex>
#include <string>

std::string text = "abc 123 def 456";
std::regex pattern{R"(\d+)"};

// 반복자 생성
auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
auto end = std::sregex_iterator();

// 순회
for (auto it = begin; it != end; ++it) {
    std::smatch match = *it;
    std::cout << match.str() << std::endl;
}

실전 예시

예시 1: 단어 추출

#include <regex>
#include <vector>

std::vector<std::string> extractWords(const std::string& text) {
    std::regex pattern{R"(\b\w+\b)"};
    
    auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
    auto end = std::sregex_iterator();
    
    std::vector<std::string> words;
    for (auto it = begin; it != end; ++it) {
        words.push_back(it->str());
    }
    
    return words;
}

int main() {
    auto words = extractWords("Hello, World! C++ 2026");
    
    for (const auto& word : words) {
        std::cout << word << std::endl;
    }
    // Hello
    // World
    // C
    // 2026
}

예시 2: 캡처 그룹

#include <regex>

int main() {
    std::string text = "[email protected], [email protected]";
    std::regex pattern{R"((\w+)@(\w+\.\w+))"};
    
    auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
    auto end = std::sregex_iterator();
    
    for (auto it = begin; it != end; ++it) {
        std::smatch match = *it;
        std::cout << "이메일: " << match[0] << std::endl;
        std::cout << "사용자: " << match[1] << std::endl;
        std::cout << "도메인: " << match[2] << std::endl;
        std::cout << std::endl;
    }
}

예시 3: URL 파싱

#include <regex>

struct URL {
    std::string protocol;
    std::string host;
    std::string path;
};

std::vector<URL> extractURLs(const std::string& text) {
    std::regex pattern{R"((https?)://([^/]+)(/[^\s]*))"};
    
    auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
    auto end = std::sregex_iterator();
    
    std::vector<URL> urls;
    for (auto it = begin; it != end; ++it) {
        std::smatch match = *it;
        urls.push_back({
            match[1].str(),  // protocol
            match[2].str(),  // host
            match[3].str()   // path
        });
    }
    
    return urls;
}

예시 4: 토큰 분할

#include <regex>

std::vector<std::string> tokenize(const std::string& text) {
    std::regex pattern{R"(\s+)"};  // 공백
    
    std::sregex_token_iterator begin(text.begin(), text.end(), pattern, -1);
    std::sregex_token_iterator end;
    
    return {begin, end};
}

int main() {
    auto tokens = tokenize("Hello   World  C++");
    
    for (const auto& token : tokens) {
        std::cout << "[" << token << "]" << std::endl;
    }
    // [Hello]
    // [World]
    // [C++]
}

regex_token_iterator

std::string text = "a,b,c,d";
std::regex pattern{","};

// -1: 구분자 제외
std::sregex_token_iterator begin(text.begin(), text.end(), pattern, -1);
std::sregex_token_iterator end;

for (auto it = begin; it != end; ++it) {
    std::cout << *it << std::endl;
}
// a
// b
// c
// d

자주 발생하는 문제

문제 1: 반복자 수명

// ❌ 댕글링
auto getIterator() {
    std::string text = "hello 123";
    std::regex pattern{R"(\d+)"};
    return std::sregex_iterator(text.begin(), text.end(), pattern);
    // text 소멸
}

// ✅ 문자열 수명 보장
std::string text = "hello 123";
auto it = std::sregex_iterator(text.begin(), text.end(), pattern);

문제 2: 성능

// regex는 느림
std::regex pattern{R"(\d+)"};

// ❌ 매번 컴파일
for (const auto& text : texts) {
    std::regex pattern{R"(\d+)"};  // 반복 컴파일
    std::regex_search(text, pattern);
}

// ✅ 한 번만 컴파일
std::regex pattern{R"(\d+)"};
for (const auto& text : texts) {
    std::regex_search(text, pattern);
}

문제 3: 빈 매치

std::string text = "hello";
std::regex pattern{R"(\d*)"};  // 0개 이상

// 빈 매치 가능
auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
auto end = std::sregex_iterator();

for (auto it = begin; it != end; ++it) {
    if (!it->str().empty()) {
        std::cout << it->str() << std::endl;
    }
}

문제 4: 그룹 인덱스

std::string text = "[email protected]";
std::regex pattern{R"((\w+)@(\w+)\.(\w+))"};

std::smatch matches;
if (std::regex_match(text, matches, pattern)) {
    // matches[0]: 전체 매치
    // matches[1]: 첫 번째 그룹
    // matches[2]: 두 번째 그룹
    // ...
}

활용 패턴

// 1. 검증
bool isValid = std::regex_match(text, pattern);

// 2. 검색
std::smatch matches;
std::regex_search(text, matches, pattern);

// 3. 치환
auto result = std::regex_replace(text, pattern, replacement);

// 4. 모든 매치
auto it = std::sregex_iterator(begin, end, pattern);

정규식 반복 매칭의 동작

std::regex_search는 한 번에 한 구간만 찾습니다. 문자열 안의 모든 비중첩 매치를 순회하려면 std::regex_iterator(문자 시퀀스용) / std::sregex_iterator(std::string 반복자용)를 씁니다. 반복자는 내부적으로 이전 매치 끝 다음 위치부터 다시 regex_search를 호출하는 패턴으로 구현됩니다.

  • 전역 매치가 아님: 기본 반복자는 부분 일치를 나열합니다. 전체 문자열이 패턴과 정확히 일치하는지 보려면 regex_match를 쓰세요.
  • 중첩·겹침: 표준 반복자는 일반적으로 다음 검색 시작점을 매치 끝으로 옮기므로, 겹치는 패턴(예: a 위 aa)은 요구사항에 따라 별도 설계가 필요합니다.

sregex_iterator 타입 계열

  • sregex_iterator: std::string::const_iterator 범위 + std::regex로 초기화.
  • cregex_iterator: const char* 범위용.
  • wsregex_iterator: std::wstring용.

종료 반복자는 std::sregex_iterator() 기본 생성으로 두는 관용구가 널리 쓰입니다.

auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
auto end   = std::sregex_iterator();
for (auto it = begin; it != end; ++it) {
    const std::smatch& m = *it;
    // m.ready(), m.size(), m.str(n)
}

실전: 로그 파싱 예시

아래는 타임스탬프·레벨·메시지를 한 줄에서 뽑는 예시입니다(패턴은 로그 포맷에 맞게 조정).

#include <regex>
#include <string>
#include <iostream>
#include <vector>

struct LogLine {
    std::string timestamp;
    std::string level;
    std::string message;
};

// 예: "2026-03-30 12:00:00 ERROR something failed"
bool parseLogLine(const std::string& line, LogLine& out) {
    static const std::regex re(
        R"((\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (\w+) (.*))");
    std::smatch m;
    if (!std::regex_match(line, m, re)) {
        return false;
    }
    out.timestamp = m[1].str();
    out.level = m[2].str();
    out.message = m[3].str();
    return true;
}

// 여러 줄에서 특정 레벨만 모으기
std::vector<std::string> extractErrors(const std::string& text) {
    std::regex levelLine(R"(\b(ERROR|CRITICAL)\b.*)");
    auto begin = std::sregex_iterator(text.begin(), text.end(), levelLine);
    auto end = std::sregex_iterator();
    std::vector<std::string> errors;
    for (auto it = begin; it != end; ++it) {
        errors.push_back(it->str());
    }
    return errors;
}

팁: 한 파일을 통째로 string에 올린 뒤 줄 단위로 나누면 regex_iterator는 “줄 안의 여러 토큰”에, 줄 단위 루프는 “레코드 경계”에 쓰기 좋습니다.

성능 주의사항

  • 컴파일 비용: std::regex 생성자는 패턴을 컴파일합니다. 루프 밖에서 한 번만 만들고 재사용하세요.
  • 엔진: GCC/LLVM의 std::regex는 매우 큰 입력이나 복잡한 패턴에서 기대보다 느릴 수 있습니다. 핫 경로면 프로파일링 후 Boost.Regex, RE2 스타일 라이브러리, 또는 수동 파서를 검토합니다.
  • 할당: smatch/sregex_iterator 사용은 내부적으로 부분 문자열을 만들 수 있습니다. 대량 로그에서는 string_view 기반 커스텀 스캐너나 고정 버퍼 파서가 더 나을 수 있습니다.
  • std::regex_constants::optimize: 구현에 따라 최적화를 힌트할 수 있으나, 항상 빨라진다는 보장은 없음—측정이 우선입니다.

FAQ

Q1: Regex는?

A: 정규 표현식 (C++11).

Q2: 반복자?

A: regex_iterator 모든 매치.

Q3: 캡처 그룹?

A: () 사용. matches[N].

Q4: 성능?

A: 느림. 컴파일 재사용.

Q5: 토큰 분할?

A: regex_token_iterator.

Q6: 학습 리소스는?

A:

  • “Mastering Regular Expressions”
  • cppreference.com
  • “C++ Primer”

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

  • C++ Regex | “정규 표현식” 가이드
  • C++ subrange | “부분 범위” 가이드
  • C++ 정규표현식 | “regex” 완벽 가이드

관련 글

  • C++ Regex |
  • C++ async & launch |
  • C++ Atomic Operations |
  • C++ Attributes |
  • C++ auto 키워드 |