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

From cppreference.com
< cpp‎ | regex‎ | basic regex

basic_regex(); | (1) | (since C++11)
explicit basic_regex( const CharT* s, flag_type f = std::regex_constants::ECMAScript ); | (2) | (since C++11)
basic_regex( const CharT* s, std::size_t count, flag_type f = std::regex_constants::ECMAScript ); | (3) | (since C++11)
basic_regex( const basic_regex& other ); | (4) | (since C++11)
basic_regex( basic_regex&& other ) noexcept; | (5) | (since 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) | (since C++11)
template< class ForwardIt > basic_regex( ForwardIt first, ForwardIt last, flag_type f = std::regex_constants::ECMAScript ); | (7) | (since C++11)
basic_regex( std::initializer_list<CharT> init, flag_type f = std::regex_constants::ECMAScript ); | (8) | (since C++11)

Constructs a new regular expression from a sequence of characters interpreted according to the flags f.

1) Default constructor. Constructs an empty regular expression which will match nothing.
2) Constructs a regex from a null-terminated string s.
3) Constructs a regex from a sequence of count characters, pointed to by s.
4) Copy constructor. Constructs a regex by copying other.
5) Move constructor. Constructs a regex with the contents of other using move semantics.
6) Constructs a regex from a string str.
7) Range constructor. Constructs the string with the contents of the range `[`first`,` last`)`.
8) Initializer list constructor. Constructs the string with the contents of the initializer list init.

### Parameters

s | - | pointer to a null-terminated string
count | - | length of a character sequence used to initialize the regex
first, last | - | range of a character sequence used to initialize the regex
str | - | a basic_string used as a source used to initialize the regex
other | - | another regex to use as source to initialize the regex
init | - | initializer list used to initialize the regex
f | - | flags used to guide the interpretation of the character sequence as a regular expression
Type requirements
- `ForwardIt` must meet the requirements of LegacyForwardIterator.

### Exceptions

1) May throw implementation-defined exceptions.
2-3) std::regex_error if the supplied regular expression is not valid.
4) May throw implementation-defined exceptions.
6-8) std::regex_error if the supplied regular expression is not valid.

### Example

Run this code

    #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";

        // Matches one or more digits
        std::string pattern_text = "\\d+";
        std::cout << "digits (" << pattern_text << "):\n";
        auto pattern = std::regex(pattern_text);
        match_and_print(text, pattern);

        // Matches one or more characters split by space
        pattern_text = "[^\\s]+";
        std::cout << "words (" << pattern_text << "):\n";
        pattern = std::regex(pattern_text);
        match_and_print(text, pattern);

        // Matches one or more characters split by space
        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);

        // Matches one non digits, non alphabet
        pattern_text = "[^0-9A-Za-z]";
        std::cout << "symbol (" << pattern_text << "):\n";
        pattern = std::regex(pattern_text);
        match_and_print(text, pattern);

        // Matches one or more lowercase
        pattern_text = "[a-z]+";
        std::cout << "lowercase (" << pattern_text << "):\n";
        pattern = std::regex(pattern_text);
        match_and_print(text, pattern);

        // Matches one or more lowercase with std::regex::icase flag
        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);

        // Matches basic POSIX regular expression
        pattern_text = "[[:digit:]]+";
        std::cout << "basic POSIX regex (" << pattern_text << "):\n";
        pattern = std::regex(pattern_text, std::regex::basic);
        match_and_print(text, pattern);

        // Matches extended POSIX regular expression
        pattern_text = "[[:digit:]]+";
        std::cout << "extended POSIX regex (" << pattern_text << "):\n";
        pattern = std::regex(pattern_text, std::regex::extended);
        match_and_print(text, pattern);
    }

Output:

    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:]]+):
    no match found

    extended POSIX regex ([[:digit:]]+):
    1. "12345"

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/regex/basic_regex/basic_regex&oldid=152012"