Regular expressions library (since C++11)

Die Regular-Expressions-Bibliothek stellt eine Klasse bereit, die reguläre Ausdrücke repräsentiert, eine Art Minisprache, die zur Mustererkennung innerhalb von Zeichenketten verwendet wird. Fast alle Operationen mit Regexes können durch die Verarbeitung mehrerer der folgenden Objekte charakterisiert werden:

• Zielsequenz . Die Zeichensequenz, in der nach einem Muster gesucht wird. Dies kann ein durch zwei Iteratoren spezifizierter Bereich, eine nullterminierte Zeichenkette oder ein std::string sein.

• Pattern . Dies ist der reguläre Ausdruck selbst. Er bestimmt, was als Übereinstimmung gilt. Es ist ein Objekt vom Typ std::basic_regex , konstruiert aus einem String mit spezieller Grammatik .

• Matched array . Die Informationen über Matches können als ein Objekt vom Typ std::match_results abgerufen werden.

• Ersetzungszeichenkette . Dies ist eine Zeichenkette, die bestimmt, wie die Übereinstimmungen ersetzt werden.

Reguläre Ausdrucksgrammatiken

Muster und Ersetzungszeichenfolgen unterstützen die folgenden regulären Ausdrucksgrammatiken:

• Modifizierte ECMAScript-Regular-Expression-Grammatik . Dies ist die Standardgrammatik.
• Grundlegende POSIX-Regular-Expression-Grammatik .
• Erweiterte POSIX-Regular-Expression-Grammatik .
• Die Regular-Expression-Grammatik, die vom awk -Utility in POSIX verwendet wird.
• Die Regular-Expression-Grammatik, die vom grep -Utility in POSIX verwendet wird. Diese ist effektiv identisch mit der grundlegenden POSIX-Regular-Expression-Grammatik, mit der Ergänzung von Newline ' \n ' als Alternativtrennzeichen.
• Die Regular-Expression-Grammatik, die vom grep -Utility mit der - E -Option in POSIX verwendet wird. Diese ist effektiv identisch mit der erweiterten POSIX-Regular-Expression-Grammatik, mit der Ergänzung von Newline ' \n ' als zusätzlichem Alternativtrennzeichen neben '|' .

Einige Grammatikvarianten (wie z.B. Groß-/Kleinschreibung-ignorierende Suche) sind ebenfalls verfügbar, siehe diese Seite für Details.

Hauptklassen

Diese Klassen kapseln einen regulären Ausdruck und die Ergebnisse der Übereinstimmung eines regulären Ausdrucks innerhalb einer Zielzeichenfolge.

Algorithmen

Diese Funktionen werden verwendet, um den regulären Ausdruck, der in einem Regex gekapselt ist, auf eine Zielzeichenfolge anzuwenden.

Iteratoren

Die Regex-Iteratoren werden verwendet, um die gesamte Menge der regulären Ausdrücke, die in einer Sequenz gefunden wurden, zu durchlaufen.

Exceptions

Diese Klasse definiert den Typ von Objekten, die als Ausnahmen ausgelöst werden, um Fehler aus der regulären Ausdrücke-Bibliothek zu melden.

Traits

Die Regex-Traits-Klasse wird verwendet, um die lokalisierbaren Aspekte eines Regex zu kapseln.

Konstanten

Beispiel

#include <iostream>
#include <iterator>
#include <regex>
#include <string>
int main()
{
    std::string s = "Some people, when confronted with a problem, think "
        "\"I know, I'll use regular expressions.\" "
        "Now they have two problems.";
    std::regex self_regex("REGULAR EXPRESSIONS",
        std::regex_constants::ECMAScript | std::regex_constants::icase);
    if (std::regex_search(s, self_regex))
        std::cout << "Text contains the phrase 'regular expressions'\n";
    std::regex word_regex("(\\w+)");
    auto words_begin = 
        std::sregex_iterator(s.begin(), s.end(), word_regex);
    auto words_end = std::sregex_iterator();
    std::cout << "Found "
              << std::distance(words_begin, words_end)
              << " words\n";
    const int N = 6;
    std::cout << "Words longer than " << N << " characters:\n";
    for (std::sregex_iterator i = words_begin; i != words_end; ++i)
    {
        std::smatch match = *i;
        std::string match_str = match.str();
        if (match_str.size() > N)
            std::cout << "  " << match_str << '\n';
    }
    std::regex long_word_regex("(\\w{7,})");
    std::string new_s = std::regex_replace(s, long_word_regex, "[$&]");
    std::cout << new_s << '\n';
}

Text contains the phrase 'regular expressions'
Found 20 words
Words longer than 6 characters:
  confronted
  problem
  regular
  expressions
  problems
Some people, when [confronted] with a [problem], think 
"I know, I'll use [regular] [expressions]." Now they have two [problems].