std:: regex_iterator

std::regex_iterator est un itérateur en lecture seule qui accède aux correspondances individuelles d'une expression régulière dans la séquence de caractères sous-jacente. Il satisfait aux exigences d'un LegacyForwardIterator , sauf que pour les valeurs déréférençables a et b avec a == b , * a et * b ne seront pas liés au même objet.

À la construction, et à chaque incrémentation, il appelle std::regex_search et mémorise le résultat (c'est-à-dire sauvegarde une copie de la valeur std:: match_results < BidirIt > ). Le premier objet peut être lu lors de la construction de l'itérateur ou lors du premier déréférencement. Sinon, le déréférencement ne renvoie qu'une copie de la correspondance d'expression régulière la plus récemment obtenue.

L'itérateur construit par défaut std::regex_iterator est l'itérateur de fin de séquence. Lorsqu'un std::regex_iterator valide est incrémenté après avoir atteint la dernière correspondance ( std::regex_search retourne false ), il devient égal à l'itérateur de fin de séquence. Le déréférencement ou l'incrémentation ultérieure invoque un comportement indéfini.

Une implémentation typique de std::regex_iterator contient les itérateurs de début et de fin pour la séquence sous-jacente (deux instances de BidirIt ), un pointeur vers l'expression régulière ( const regex_type * ), les indicateurs de correspondance ( std::regex_constants::match_flag_type ), et la correspondance actuelle ( std:: match_results < BidirIt > ).

Exigences de type

Spécialisations

Plusieurs spécialisations pour les types courants de séquences de caractères sont définies :

Types membres

Membres de données

Fonctions membres

Notes

Il est de la responsabilité du programmeur de s'assurer que l'objet std::basic_regex passé au constructeur de l'itérateur survive à l'itérateur. Comme l'itérateur stocke un pointeur vers l'expression rationnelle, incrémenter l'itérateur après la destruction de l'expression rationnelle accède à un pointeur suspendu.

Si la partie de l'expression régulière qui correspond est simplement une assertion ( ^ , $ , \b , \B ), la correspondance stockée dans l'itérateur est une correspondance de longueur zéro, c'est-à-dire, match [ 0 ] . first == match [ 0 ] . second .

Exemple

#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';
    }
}

Found 3 words:
Quick
brown
fox.

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

1. ↑ iterator_category n'a pas été modifié par la résolution, car le changer en std::input_iterator_tag pourrait compromettre trop de code existant.

Voir aussi