std:: regex_token_iterator

std::regex_token_iterator est un LegacyForwardIterator en lecture seule qui accède aux sous-correspondances individuelles de chaque correspondance d'une expression régulière dans la séquence de caractères sous-jacente. Il peut également être utilisé pour accéder aux parties de la séquence qui n'ont pas été correspondantes par l'expression régulière donnée (par exemple, en tant que tokeniseur).

Lors de la construction, il construit un std::regex_iterator et à chaque incrément, il parcourt les sous-correspondances demandées depuis le match_results actuel, en incrémentant le std::regex_iterator sous-jacent lors du passage au-delà de la dernière sous-correspondance.

L'itérateur construit par défaut std::regex_token_iterator est l'itérateur de fin de séquence. Lorsqu'un std::regex_token_iterator valide est incrémenté après avoir atteint la dernière sous-correspondance de la dernière correspondance, 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.

Juste avant de devenir l'itérateur de fin de séquence, un std::regex_token_iterator peut devenir un suffix iterator , si l'index - 1 (fragment non correspondant) apparaît dans la liste des indices de sous-correspondance demandés. Un tel itérateur, s'il est déréférencé, retourne un match_results correspondant à la séquence de caractères entre la dernière correspondance et la fin de séquence.

Une implémentation typique de std::regex_token_iterator maintient l'itérateur sous-jacent std::regex_iterator , un conteneur (par exemple std:: vector < int > ) des indices de sous-correspondance demandés, un compteur interne égal à l'index de la sous-correspondance, un pointeur vers std::sub_match , pointant vers la sous-correspondance actuelle de la correspondance courante, et un objet std::match_results contenant la dernière séquence de caractères non correspondante (utilisée en mode tokeniseur).

Exigences de type

Spécialisations

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

Types membres

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. Étant donné que l'itérateur stocke un std::regex_iterator qui contient un pointeur vers la regex, incrémenter l'itérateur après la destruction de la regex entraîne un comportement indéfini.

Exemple

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <regex>
int main()
{
    // Tokenization (non-matched fragments)
    // Note that regex is matched only two times; when the third value is obtained
    // the iterator is a suffix iterator.
    const std::string text = "Quick brown fox.";
    const std::regex ws_re("\\s+"); // whitespace
    std::copy(std::sregex_token_iterator(text.begin(), text.end(), ws_re, -1),
              std::sregex_token_iterator(),
              std::ostream_iterator<std::string>(std::cout, "\n"));
    std::cout << '\n';
    // Iterating the first submatches
    const std::string html = R"(<p><a href="http://google.com">google</a> )"
                             R"(< a HREF ="http://cppreference.net">cppreference</a>\n</p>)";
    const std::regex url_re(R"!!(<\s*A\s+[^>]*href\s*=\s*"([^"]*)")!!", std::regex::icase);
    std::copy(std::sregex_token_iterator(html.begin(), html.end(), url_re, 1),
              std::sregex_token_iterator(),
              std::ostream_iterator<std::string>(std::cout, "\n"));
}

Quick
brown
fox.
http://google.com
http://cppreference.net

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 casser trop de code existant.