Namespaces
Variants

std::basic_regex<CharT,Traits>:: basic_regex

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
(C++11)
(C++11)
Algorithms
(C++11)
(C++11)
(C++11)
Iterators
(C++11)
(C++11)
Exceptions
(C++11)
Traits
(C++11)
Constants
(C++11)
(C++11)
(C++11)
Regex Grammar
(C++11)
std::basic_regex
basic_regex ( ) ;
(1) (C++11부터)
explicit basic_regex ( const CharT * s,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(2) (C++11부터)
basic_regex ( const CharT * s, std:: size_t count,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(3) (C++11부터)
basic_regex ( const basic_regex & other ) ;
(4) (C++11부터)
basic_regex ( basic_regex && other ) noexcept ;
(5) (C++11부터)
template < class ST, class SA >

explicit basic_regex ( const std:: basic_string < CharT,ST,SA > & str,

flag_type f = std:: regex_constants :: ECMAScript ) ;
(6) (C++11부터)
template < class ForwardIt >

basic_regex ( ForwardIt first, ForwardIt last,

flag_type f = std:: regex_constants :: ECMAScript ) ;
(7) (C++11부터)
basic_regex ( std:: initializer_list < CharT > init,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(8) (C++11부터)

플래그 f 에 따라 해석된 문자 시퀀스로부터 새로운 정규 표현식을 생성합니다.

1) 기본 생성자. 아무것도 매치하지 않는 빈 정규 표현식을 생성합니다.
2) 널 종료 문자열 s 로부터 정규식을 생성합니다.
3) count 개의 문자 시퀀스로부터 정규식을 생성합니다. 이 시퀀스는 s 가 가리키는 위치에서 시작됩니다.
4) 복사 생성자. other 를 복사하여 regex를 생성합니다.
5) 이동 생성자. 이동 의미론을 사용하여 other 의 내용으로 regex를 생성합니다.
6) 문자열로부터 정규식을 생성합니다 str .
7) 범위 생성자. 지정된 범위 [ first , last ) 의 내용으로 문자열을 생성합니다.
8) 초기화 리스트 생성자. initializer list init 의 내용으로 문자열을 생성합니다.

매개변수

s - 널 종료 문자열에 대한 포인터
count - 정규 표현식 초기화에 사용되는 문자 시퀀스의 길이
first, last - 정규 표현식 초기화에 사용되는 문자 시퀀스의 범위
str - 정규 표현식 초기화에 소스로 사용되는 basic_string
other - 정규 표현식 초기화에 소스로 사용할 다른 regex
init - 정규 표현식 초기화에 사용되는 초기화 리스트
f - 문자 시퀀스를 정규 표현식으로 해석하는 방법을 안내하는 플래그
타입 요구사항
-
ForwardIt 는 LegacyForwardIterator 요구사항을 충족해야 합니다.

예외

1) 구현 정의 예외를 발생시킬 수 있습니다.
2,3) std::regex_error 제공된 정규 표현식이 유효하지 않은 경우.
4) 구현에서 정의된 예외를 발생시킬 수 있습니다.
6-8) std::regex_error 제공된 정규 표현식이 유효하지 않은 경우.

예제

이 코드 실행 
#include <iomanip>
#include <iostream>
#include <regex>
#include <string>
void match_and_print(const std::string& text, const std::regex& pattern)
{
    std::sregex_iterator it(text.begin(), text.end(), pattern), it_end;
    int count = 0;
    for (; it != it_end; ++it)
    {
        const std::smatch& match = *it;
        std::cout << ++count << ". " << std::quoted(match.str()) << '\n';
    }
    std::cout << (count ? "\n" : "no match found\n\n");
}
int main()
{
    const std::string text = "Hello, World! 12345";
    // 하나 이상의 숫자와 일치
    std::string pattern_text = "\\d+";
    std::cout << "digits (" << pattern_text << "):\n";
    auto pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // 공백으로 구분된 하나 이상의 문자와 일치
    pattern_text = "[^\\s]+";
    std::cout << "words (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // 공백으로 구분된 하나 이상의 문자와 일치
    pattern_text = "[a-zA-Z]+";
    std::cout << "words without symbols and digits (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // 숫자나 알파벳이 아닌 하나의 문자와 일치
    pattern_text = "[^0-9A-Za-z]";
    std::cout << "symbol (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // 하나 이상의 소문자와 일치
    pattern_text = "[a-z]+";
    std::cout << "lowercase (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // std::regex::icase 플래그를 사용한 하나 이상의 소문자와 일치
    pattern_text = "[a-z]+";
    std::cout << "lowercase with ignore case flag (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::icase);
    match_and_print(text, pattern);
    // 기본 POSIX 정규 표현식과 일치
    pattern_text = "[[:digit:]]+";
    std::cout << "basic POSIX regex (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::basic);
    match_and_print(text, pattern);
    // 확장 POSIX 정규 표현식과 일치
    pattern_text = "[[:digit:]]+";
    std::cout << "extended POSIX regex (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::extended);
    match_and_print(text, pattern);
}

출력: 

digits (\d+):
1. "12345"
words ([^\s]+):
1. "Hello,"
2. "World!"
3. "12345"
words without symbols and digits ([a-zA-Z]+):
1. "Hello"
2. "World"
symbol ([^0-9A-Za-z]):
1. ","
2. " "
3. "!"
4. " "
lowercase ([a-z]+):
1. "ello"
2. "orld"
lowercase with ignore case flag ([a-z]+):
1. "Hello"
2. "World"
basic POSIX regex ([[:digit:]]+):
일치하는 항목 없음
extended POSIX regex ([[:digit:]]+):
1. "12345"