std::regex_iterator — cppreference.com
De cppreference.com
<metanoindex/>
<tbody> </tbody>
|
|
(depuis C++11) | |
std::regex_iterator est un ForwardIterator en lecture seule qui permet d'accéder aux différents matchs d'une expression régulière dans la chaîne de caractères sous-jacent .
Original:
std::regex_iterator is a read-only ForwardIterator that accesses the individual matches of a regular expression within the underlying character sequence.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
sur la construction et sur chaque augmentation, il appelle std::regex_search et se souvient du résultat (qui est, enregistre une copie de la valeur std::match_results<BidirIt>). Le premier objet peut être lu lorsque l'itérateur est construit ou lorsque le déréférencement premier pas est fait. Sinon, le déréférencement retourne uniquement une copie de le match le plus récemment obtenu regex .
Original:
On construction, and on every increment, it calls std::regex_search and remembers the result (that is, saves a copy of the value std::match_results<BidirIt>). The first object may be read when the iterator is constructed or when the first dereferencing is done. Otherwise, dereferencing only returns a copy of the most recently obtained regex match.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
La valeur par défaut est construit std::regex_iterator l'itérateur de fin de séquence. Quand un std::regex_iterator valide est incrémenté après avoir atteint le dernier match (std::regex_search retours false), elle devient égale à la fin de itérateur séquence. déréférencement ou incrémenter il invoque par ailleurs un comportement indéfini .
Original:
The default-constructed std::regex_iterator is the end-of-sequence iterator. When a valid std::regex_iterator is incremented after reaching the last match (std::regex_search returns false), it becomes equal to the end-of-sequence iterator. Dereferencing or incrementing it further invokes undefined behavior.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Une application typique de std::regex_iterator détient le début et de fin pour les itérateurs la séquence sous-jacente (deux instances de BidirIt), un pointeur sur l'expression régulière (const regex_type*) et les indicateurs de correspondance (std::regex_constants::match_flag_type), et le résultat actuel (std::match_results<BidirIt>) .
Original:
A typical implementation of std::regex_iterator holds the begin and the end iterators for the underlying sequence (two instances of BidirIt), a pointer to the regular expression (const regex_type*) and the match flags (std::regex_constants::match_flag_type), and the current match (std::match_results<BidirIt>).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Exigences de type
Spécialisations
Plusieurs spécialisations pour les types courants de séquence de caractères sont définies:
Original:
Several specializations for common character sequence types are defined:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Defined in header | |
Type d' Original: Type The text has been machine-translated via Google Translate. |
Definition |
cregex_iterator
|
regex_iterator<const char*>
|
wcregex_iterator
|
regex_iterator<const wchar_t*>
|
sregex_iterator
|
regex_iterator<std::string::const_iterator>
|
wsregex_iterator
|
regex_iterator<std::wstring::const_iterator>
|
Types de membres
| Type du membre | Définition |
value_type
|
std::match_results<BidirIt>
|
difference_type
|
std::ptrdiff_t |
pointer
|
const value_type*
|
reference
|
const value_type&
|
iterator_category
|
std::forward_iterator_tag |
regex_type
|
basic_regex<CharT, Traits>
|
Fonctions membres
construit une nouvelle regex_iterator Original: constructs a new regex_iterator The text has been machine-translated via Google Translate. (fonction membre publique) | |
(destructeur) (implicitement déclaré) |
destructs a regex_iterator, including the cached value (fonction membre publique) |
remplace un regex_iterator Original: replaces a regex_iterator The text has been machine-translated via Google Translate. (fonction membre publique) | |
compare deux regex_iterators Original: compares two regex_iterators The text has been machine-translated via Google Translate. (fonction membre publique) | |
obtient une référence à l'actuel match Original: obtains a reference to the current match The text has been machine-translated via Google Translate. (fonction membre publique) | |
progrès de la regex_iterator pour le prochain match Original: advances the regex_iterator to the next match The text has been machine-translated via Google Translate. (fonction membre publique) | |
Notes
Il est de la responsabilité du programmeur de s'assurer que l'objet std::basic_regex passé au constructeur de l'itérateur survit à l'itérateur. Parce que l'itérateur stocke un pointeur vers la regex, l'incrémentation de l'itérateur après l'expression rationnelle a été détruit accède à un pointeur dangling .
Original:
It is the programmer's responsibility to ensure that the std::basic_regex object passed to the iterator's constructor outlives the iterator. Because the iterator stores a pointer to the regex, incrementing the iterator after the regex was destroyed accesses a dangling pointer.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Si la partie de l'expression régulière qui correspond est juste une affirmation (^, $, \b, \B), le match stockées dans l'itérateur est un match de longueur nulle, c'est-à-match[0].first == match[0].second .
Original:
If the part of the regular expression that matched is just an assertion (^, $, \b, \B), the match stored in the iterator is a zero-length match, that is, match[0].first == match[0].second.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Exemple
#include <regex> #include <iterator> #include <iostream> int main() { const std::string text = "Quick brown fox."; std::regex re("[^\\s]+"); auto beg = std::sregex_iterator(text.begin(), text.end(), re); auto end = std::sregex_iterator(); std::cout << "The number of words is " << std::distance(beg, end) << '\n'; }
Résultat :
Voir aussi
identifie une correspondance d'expression régulière, y compris tous les matchs de la sous-expression Original: identifies one regular expression match, including all sub-expression matches The text has been machine-translated via Google Translate. (classe générique) [edit] | |
vérifier si une expression régulière se produit n'importe où dans une chaîne Original: check if a regular expression occurs anywhere within a string The text has been machine-translated via Google Translate. (fonction générique) | |