std::regex_iterator
| Definiert in Header <regex> |
||
| template< class BidirIt, |
(seit C++11) | |
std::regex_iterator ist ein schreibgeschützter Iterator, der auf die einzelnen Übereinstimmungen eines regulären Ausdrucks innerhalb der zugrunde liegenden Zeichensequenz zugreift. Er erfüllt die Anforderungen eines LegacyForwardIterator, mit der Ausnahme, dass für dereferenzierbare Werte a und b mit a == b, *a und *b nicht an dasselbe Objekt gebunden sind.
Bei der Konstruktion und bei jeder Inkrementierung wird std::regex_search aufgerufen und das Ergebnis gespeichert (d. h. eine Kopie des Werts std::match_results<BidirIt> wird gespeichert). Das erste Objekt kann beim Konstruieren des Iterators oder bei der ersten Dereferenzierung gelesen werden. Andernfalls gibt die Dereferenzierung nur eine Kopie der zuletzt erhaltenen regulären Ausdrucksübereinstimmung zurück.
Der standardkonstruierte std::regex_iterator ist der End-of-Sequence-Iterator. Wenn ein gültiger std::regex_iterator nach Erreichen der letzten Übereinstimmung (wenn std::regex_search false zurückgibt) inkrementiert wird, wird er gleich dem End-of-Sequence-Iterator. Das Dereferenzieren oder weitere Inkrementieren führt zu undefiniertem Verhalten.
Eine typische Implementierung von std::regex_iterator speichert die Beginn- und End-Iteratoren für die zugrunde liegende Sequenz (zwei Instanzen von BidirIt), einen Zeiger auf den regulären Ausdruck (const regex_type*), die Übereinstimmungsflags (std::regex_constants::match_flag_type) und die aktuelle Übereinstimmung (std::match_results<BidirIt>).
Inhalt |
[edit] Typanforderungen
-BidirIt muss die Anforderungen von LegacyBidirectionalIterator erfüllen. |
[edit] Spezialisierungen
Mehrere Spezialisierungen für gängige Zeichensequenztypen sind definiert
| Definiert in Header
<regex> | |
| Typ | Definition |
std::cregex_iterator
|
std::regex_iterator<const char*> |
std::wcregex_iterator
|
std::regex_iterator<const wchar_t*> |
std::sregex_iterator
|
std::regex_iterator<std::string::const_iterator> |
std::wsregex_iterator
|
std::regex_iterator<std::wstring::const_iterator> |
[edit] Member-Typen
| Typ | Definition |
value_type
|
std::match_results<BidirIt> |
difference_type
|
std::ptrdiff_t |
Zeiger
|
const value_type* |
Referenz
|
const value_type& |
iterator_category
|
std::forward_iterator_tag |
iterator_concept (C++20) |
std::input_iterator_tag |
regex_type
|
std::basic_regex<CharT, Traits> |
[edit] Datenmember
| Mitglied | Beschreibung |
BidiIt begin (private) |
der Begin-Iterator ((exposition-only member object*) |
BidiIt end (private) |
der End-Iterator ((exposition-only member object*) |
const regex_type* pregex (private) |
ein Zeiger auf einen regulären Ausdruck ((exposition-only member object*) |
regex_constants::match_flag_type flags (private) |
ein Flag ((exposition-only member object*) |
match_results<BidirIt> match (private) |
die aktuelle Übereinstimmung ((exposition-only member object*) |
[edit] Member-Funktionen
konstruiert einen neuen regex_iterator(public member function) | |
| (Destruktor) (implizit deklariert) |
destruiert einen regex_iterator, einschließlich des zwischengespeicherten Werts(public member function) |
| weist Inhalte zu (public member function) | |
| (in C++20 entfernt) |
vergleicht zwei regex_iterators(public member function) |
| greift auf die aktuelle Übereinstimmung zu (public member function) | |
| rückt den Iterator zur nächsten Übereinstimmung vor (public member function) |
[edit] Hinweise
Es liegt in der Verantwortung des Programmierers sicherzustellen, dass das Objekt std::basic_regex, das an den Konstruktor des Iterators übergeben wird, den Iterator überlebt. Da der Iterator einen Zeiger auf den regulären Ausdruck speichert, führt das Inkrementieren des Iterators, nachdem der reguläre Ausdruck zerstört wurde, zum Zugriff auf einen hängenden Zeiger.
Wenn der Teil des regulären Ausdrucks, der übereinstimmt, nur eine Assertion ist (^, $, \b, \B), dann ist die im Iterator gespeicherte Übereinstimmung eine Null-Längen-Übereinstimmung, d. h. match[0].first == match[0].second.
[edit] Beispiel
#include <iostream> #include <iterator> #include <regex> #include <string> int main() { const std::string s = "Quick brown fox."; std::regex words_regex("[^\\s]+"); auto words_begin = std::sregex_iterator(s.begin(), s.end(), words_regex); auto words_end = std::sregex_iterator(); std::cout << "Found " << std::distance(words_begin, words_end) << " words:\n"; for (std::sregex_iterator i = words_begin; i != words_end; ++i) { std::smatch match = *i; std::string match_str = match.str(); std::cout << match_str << '\n'; } }
Ausgabe
Found 3 words: Quick brown fox.
[edit] Fehlerberichte
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| LWG 3698 (P2770R0) |
C++20 | regex_iterator war ein forward_iteratorwährend er ein Stashing-Iterator war |
machte ihn zu einem input_iterator[1] |
- ↑
iterator_categorywurde durch die Auflösung nicht verändert, da eine Änderung zu std::input_iterator_tag zu viel bestehenden Code brechen könnte.
[edit] Siehe auch
| (C++11) |
identifiziert eine Übereinstimmung eines regulären Ausdrucks, einschließlich aller Übereinstimmungen von Unterausdrücken (Klassenvorlage) |
| (C++11) |
versucht, einen regulären Ausdruck an einen beliebigen Teil einer Zeichensequenz anzupassen (Funktionsvorlage) |
