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

basic_regex ( ForwardIt first, ForwardIt last,

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

Konstruiert einen neuen regulären Ausdruck aus einer Zeichensequenz, die gemäß den Flags f interpretiert wird.

1) Standardkonstruktor. Konstruiert eine leere reguläre Ausdruckszeichenfolge, die nichts übereinstimmen wird.
2) Konstruiert einen regulären Ausdruck aus einem nullterminierten String s .
3) Konstruiert einen regulären Ausdruck aus einer Sequenz von count Zeichen, gezeigt durch s .
4) Copy-Konstruktor. Konstruiert eine Regex durch Kopieren von other .
5) Move-Konstruktor. Konstruiert einen regulären Ausdruck mit den Inhalten von other unter Verwendung von Move-Semantik.
6) Konstruiert einen regulären Ausdruck aus einem String str .
7) Bereichskonstruktor. Konstruiert den String mit den Inhalten des Bereichs [ first , last ) .
8) Initializer-List-Konstruktor. Konstruiert den String mit den Inhalten der Initialisierungsliste init .

Parameter

s - Zeiger auf einen nullterminierten String
count - Länge einer Zeichensequenz zur Initialisierung des Regex
first, last - Bereich einer Zeichensequenz zur Initialisierung des Regex
str - eine basic_string, die als Quelle zur Initialisierung des Regex dient
other - ein weiterer Regex, der als Quelle zur Initialisierung des Regex verwendet wird
init - Initialisierungsliste zur Initialisierung des Regex
f - Flags, die zur Steuerung der Interpretation der Zeichensequenz als regulären Ausdruck verwendet werden
Typanforderungen
-
ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.

Exceptions

1) Kann implementierungsdefinierte Ausnahmen werfen.
2,3) std::regex_error wenn der übergebene reguläre Ausdruck nicht gültig ist.
4) Kann implementierungsdefinierte Ausnahmen werfen.
6-8) std::regex_error falls der übergebene reguläre Ausdruck nicht gültig ist.

Beispiel

Diesen Code ausführen 
#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" : "keine Übereinstimmung gefunden\n\n");
}
int main()
{
    const std::string text = "Hello, World! 12345";
    // Findet eine oder mehrere Ziffern
    std::string pattern_text = "\\d+";
    std::cout << "Ziffern (" << pattern_text << "):\n";
    auto pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Findet ein oder mehrere Zeichen, getrennt durch Leerzeichen
    pattern_text = "[^\\s]+";
    std::cout << "Wörter (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Findet ein oder mehrere Buchstaben
    pattern_text = "[a-zA-Z]+";
    std::cout << "Wörter ohne Symbole und Ziffern (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Findet ein Nicht-Ziffern-, Nicht-Alphabet-Zeichen
    pattern_text = "[^0-9A-Za-z]";
    std::cout << "Symbol (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Findet ein oder mehrere Kleinbuchstaben
    pattern_text = "[a-z]+";
    std::cout << "Kleinbuchstaben (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Findet ein oder mehrere Kleinbuchstaben mit std::regex::icase-Flag
    pattern_text = "[a-z]+";
    std::cout << "Kleinbuchstaben mit Groß-/Kleinschreibung ignorieren Flag (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::icase);
    match_and_print(text, pattern);
    // Findet grundlegende POSIX-Reguläre Ausdrücke
    pattern_text = "[[:digit:]]+";
    std::cout << "grundlegende POSIX-RegEx (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::basic);
    match_and_print(text, pattern);
    // Findet erweiterte POSIX-Reguläre Ausdrücke
    pattern_text = "[[:digit:]]+";
    std::cout << "erweiterte POSIX-RegEx (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::extended);
    match_and_print(text, pattern);
}

Ausgabe: 

Ziffern (\d+):
1. "12345"
Wörter ([^\s]+):
1. "Hello,"
2. "World!"
3. "12345"
Wörter ohne Symbole und Ziffern ([a-zA-Z]+):
1. "Hello"
2. "World"
Symbol ([^0-9A-Za-z]):
1. ","
2. " "
3. "!"
4. " "
Kleinbuchstaben ([a-z]+):
1. "ello"
2. "orld"
Kleinbuchstaben mit Ignore-Case-Flag ([a-z]+):
1. "Hello"
2. "World"
grundlegende POSIX-Regex ([[:digit:]]+):
keine Übereinstimmung gefunden
erweiterte POSIX-Regex ([[:digit:]]+):
1. "12345"