regex_token_iterator, classe

Classe d’itérateur pour les sous-correspondances.

Syntaxe

template<class BidIt,
   class Elem = typename std::iterator_traits<BidIt>::value_type,
   class RxTraits = regex_traits<Elem> >
class regex_token_iterator

Paramètres

BidIt
Type d'itérateur pour les sous-correspondances.

Elem
Type des éléments à faire correspondre.

RXtraits
Classe Traits des éléments.

Notes

Le modèle de classe décrit un objet itérateur de transfert constant. D’un point de vue conceptuel, elle contient un objet regex_iterator utilisé pour la recherche d’expressions régulières dans une séquence de caractères. Elle extrait des objets de type sub_match<BidIt> représentant les sous-correspondances identifiées par les valeurs d’index dans le vecteur stocké subs pour chaque correspondance d’expression régulière.

La valeur d’index -1 désigne la séquence de caractères qui commence immédiatement après la fin de la correspondance d’expression régulière précédente, ou le début de la séquence de caractères en l’absence de correspondance d’expression régulière précédente. Par ailleurs, la séquence s’étend jusqu’au premier caractère (sans l’inclure) de la correspondance d’expression régulière actuelle, ou jusqu’à la fin de la séquence de caractères en l’absence de correspondance actuelle. Toute autre valeur d’index idx désigne le contenu du groupe de capture situé dans it.match[idx].

Membres

Membre	Valeur par défaut
private regex_iterator<BidIt, Elem, RXtraits> it
private vector<int> subs
private int pos

Constructeurs

Constructeur	Description
regex_token_iterator	Construit l’itérateur.

Typedefs

Nom de type	Description
difference_type	Type d’une différence d’itérateur.
iterator_category	Type de la catégorie d'itérateur.
pointer	Type d'un pointeur vers une correspondance.
référence	Type d’une référence à une sous-correspondance.
regex_type	Type de l’expression régulière à mettre en correspondance.
value_type	Type d’une sous-correspondance.

Opérateurs

Opérateur	Description
operator!=	Compare l’inégalité d’itérateurs.
operator*	Accède à la sous-correspondance désignée.
operator++	Incrémente l'itérateur.
operator==	Compare des itérateurs pour déterminer s’ils sont égaux.
operator->	Accède à la sous-correspondance désignée.

Spécifications

Header :<regex>

Espace de noms : std

Exemple

#include <regex>
#include <iostream>

typedef std::regex_token_iterator<const char *> Myiter;
int main()
    {
    const char *pat = "aaxaayaaz";
    Myiter::regex_type rx("(a)a");
    Myiter next(pat, pat + strlen(pat), rx);
    Myiter end;

// show whole match
    for (; next != end; ++next)
        std::cout << "match == " << next->str() << std::endl;
    std::cout << std::endl;

// show prefix before match
    next = Myiter(pat, pat + strlen(pat), rx, -1);
    for (; next != end; ++next)
        std::cout << "match == " << next->str() << std::endl;
    std::cout << std::endl;

// show (a) submatch only
    next = Myiter(pat, pat + strlen(pat), rx, 1);
    for (; next != end; ++next)
        std::cout << "match == " << next->str() << std::endl;
    std::cout << std::endl;

// show prefixes and submatches
    std::vector<int> vec;
    vec.push_back(-1);
    vec.push_back(1);
    next = Myiter(pat, pat + strlen(pat), rx, vec);
    for (; next != end; ++next)
        std::cout << "match == " << next->str() << std::endl;
    std::cout << std::endl;

// show prefixes and whole matches
    int arr[] = {-1, 0};
    next = Myiter(pat, pat + strlen(pat), rx, arr);
    for (; next != end; ++next)
        std::cout << "match == " << next->str() << std::endl;
    std::cout << std::endl;

// other members
    Myiter it1(pat, pat + strlen(pat), rx);
    Myiter it2(it1);
    next = it1;

    Myiter::iterator_category cat = std::forward_iterator_tag();
    Myiter::difference_type dif = -3;
    Myiter::value_type mr = *it1;
    Myiter::reference ref = mr;
    Myiter::pointer ptr = &ref;

    dif = dif; // to quiet "unused" warnings
    ptr = ptr;

    return (0);
    }

match == aa
match == aa
match == aa

match ==
match == x
match == y
match == z

match == a
match == a
match == a

match ==
match == a
match == x
match == a
match == y
match == a
match == z

match ==
match == aa
match == x
match == aa
match == y
match == aa
match == z

regex_token_iterator ::d ifference_type

Type d’une différence d’itérateur.

typedef std::ptrdiff_t difference_type;

Notes

Le type est un synonyme de std::ptrdiff_t.

regex_token_iterator ::iterator_category

Type de la catégorie d'itérateur.

typedef std::forward_iterator_tag iterator_category;

Notes

Le type est un synonyme de std::forward_iterator_tag.

regex_token_iterator ::operator !=

Compare l’inégalité d’itérateurs.

bool operator!=(const regex_token_iterator& right);

Paramètres

right
Itérateur auquel comparer.

Notes

La fonction membre retourne !(*this == right).

regex_token_iterator ::operator*

Accède à la sous-correspondance désignée.

const sub_match<BidIt>& operator*();

Notes

La fonction membre retourne un objet sub_match<BidIt> représentant le groupe de capture identifié par la valeur d’index subs[pos].

regex_token_iterator ::operator++

Incrémente l'itérateur.

regex_token_iterator& operator++();

regex_token_iterator& operator++(int);

Notes

Si l'itérateur stocké it est un itérateur de fin de séquence, le premier opérateur définit la valeur stockée pos à la valeur de subs.size() (ce qui crée un itérateur de fin de séquence). Sinon, l'opérateur incrémente la valeur stockée pos ; si le résultat est égal à la valeur subs.size(), il définit la valeur stockée pos à zéro et incrémente l'itérateur stocké it. Si, suite à son incrémentation, l'itérateur est inégal à un itérateur de fin de séquence, l'opérateur ne fait rien de plus. Sinon, si la fin de la correspondance précédente était à la fin de la séquence de caractères, l'opérateur définit la valeur stockée de pos à subs.size(). Sinon, l'opérateur incrémente de manière répétée la valeur stockée pos jusqu'à pos == subs.size() ou subs[pos] == -1 (garantissant ainsi que le déréférencement suivant de l'itérateur retournera la fin de la séquence de caractères si l'une des valeurs d'index est -1). Dans tous les cas, l'opérateur retourne l'objet.

Le deuxième opérateur effectue une copie de l'objet, incrémente l'objet, puis retourne la copie.

regex_token_iterator ::operator==

Compare des itérateurs pour déterminer s’ils sont égaux.

bool operator==(const regex_token_iterator& right);

Paramètres

right
Itérateur auquel comparer.

Notes

La fonction membre retourne it == right.it && subs == right.subs && pos == right.pos.

regex_token_iterator::operator->

Accède à la sous-correspondance désignée.

const sub_match<BidIt> * operator->();

Notes

La fonction membre retourne un pointeur vers un objet sub_match<BidIt> représentant le groupe de capture identifié par la valeur d’index subs[pos].

regex_token_iterator ::p ointer

Type d'un pointeur vers une correspondance.

typedef sub_match<BidIt> *pointer;

Notes

Le type est un synonyme de sub_match<BidIt>*, où BidIt est le paramètre de modèle.

regex_token_iterator ::reference

Type d’une référence à une sous-correspondance.

typedef sub_match<BidIt>& reference;

Notes

Le type est un synonyme de sub_match<BidIt>&, où BidIt est le paramètre de modèle.

regex_token_iterator ::regex_token_iterator

Construit l’itérateur.

regex_token_iterator();

regex_token_iterator(BidIt first, BidIt last,
    const regex_type& re, int submatch = 0,
    regex_constants::match_flag_type f = regex_constants::match_default);

regex_token_iterator(BidIt first, BidIt last,
    const regex_type& re, const vector<int> submatches,
    regex_constants::match_flag_type f = regex_constants::match_default);

template <std::size_t N>
regex_token_iterator(BidIt first, BidIt last,
    const regex_type& re, const int (&submatches)[N],
    regex_constants::match_flag_type f = regex_constants::match_default);

Paramètres

first
Début de la séquence à mettre en correspondance.

last
Fin de la séquence à mettre en correspondance.

Re
Expression régulière pour les correspondances.

f
Indicateurs pour les correspondances.

Notes

Le premier constructeur construit un itérateur de fin de séquence.

Le second constructeur construit un objet dont l’itérateur stocké it est initialisé à regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), dont le vecteur stocké subs contient seulement un entier, ayant la valeur submatch, et dont la valeur stockée pos est égale à zéro. Remarque : l’objet résultant extrait la sous-correspondance identifiée par la valeur d’index submatch pour chaque correspondance d’expression régulière réussie.

Le troisième constructeur construit un objet dont l’itérateur stocké it est initialisé à regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), dont le vecteur stocké subs contient une copie de l’argument de constructeur submatches, et dont la valeur stockée pos est égale à zéro.

Le quatrième constructeur construit un objet dont l’itérateur stocké it est initialisé à regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), dont le vecteur stocké subs contient les valeurs N vers lesquelles pointe l’argument de constructeur submatches, et dont la valeur stockée pos est égale à zéro.

regex_token_iterator ::regex_type

Type de l’expression régulière à mettre en correspondance.

typedef basic_regex<Elem, RXtraits> regex_type;

Notes

Le typedef est un synonyme de basic_regex<Elem, RXtraits>.

regex_token_iterator ::value_type

Type d’une sous-correspondance.

typedef sub_match<BidIt> value_type;

Notes

Le type est un synonyme de sub_match<BidIt>, où BidIt est le paramètre de modèle.

Voir aussi

<regex>
regex_constants, classe
regex_error, classe
<fonctions regex>
regex_iterator, classe
<opérateurs regex>
regex_traits, classe
<regex> typedefs