Partager via

regex_iterator, classe

  • Article

Classe d’itérateur pour les correspondances.

Syntaxe

template<class BidIt,
   class Elem = typename std::iterator_traits<BidIt>::value_type,
   class RxTraits = regex_traits<Elem> >
class regex_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. Elle extrait les objets de type match_results<BidIt> en appliquant à plusieurs reprises son objet d’expression régulière *pregex à la séquence de caractères définie par la plage d’itérateurs [begin, end).

Constructeurs

Constructeur Description
regex_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 correspondance.
regex_type Type de l’expression régulière à mettre en correspondance.
value_type Type d'une correspondance.

Opérateurs

Opérateur Description
operator!= Compare l’inégalité d’itérateurs.
operator* Accède à la 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 correspondance désignée.

Spécifications

Header :<regex>

Espace de noms : std

Exemples

Consultez les articles suivants pour obtenir des exemples sur les expressions régulières :

// std__regex__regex_iterator.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>

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

    for (; next != end; ++next)
        std::cout << "match == " << next->str() << 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 == a
match == a
match == a

regex_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_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_iterator ::operator !=

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

bool operator!=(const regex_iterator& right);

Paramètres

right
Itérateur auquel comparer.

Notes

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

regex_iterator ::operator*

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

const match_results<BidIt>& operator*();

Notes

La fonction membre retourne la valeur stockée match.

regex_iterator ::operator++

Incrémente l'itérateur.

regex_iterator& operator++();
regex_iterator& operator++(int);

Notes

Si la correspondance actuelle n’a pas de caractères, le premier opérateur appelle regex_search(begin, end, match, *pregex, flags | regex_constants::match_prev_avail | regex_constants::match_not_null); sinon, il avance la valeur begin stockée pour pointer vers le premier caractère après la correspondance actuelle, puis appelle regex_search(begin, end, match, *pregex, flags | regex_constants::match_prev_avail). Dans chaque cas, si la recherche n’aboutit pas, l’opérateur assigne à l’objet un itérateur de fin de séquence. 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_iterator ::operator=

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

bool operator==(const regex_iterator& right);

Paramètres

right
Itérateur auquel comparer.

Notes

La fonction membre retourne la valeur true si *this et la droite sont à la fois des itérateurs de fin de séquence ou si aucun des deux n’est un itérateur de fin de séquence et begin == right.begin, end == right.endet pregex == right.pregexflags == right.flags. Sinon, elle retourne false.

regex_iterator::operator->

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

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

Notes

La fonction membre retourne l’adresse de la valeur stockée match.

regex_iterator ::p ointer

Type d'un pointeur vers une correspondance.

typedef match_results<BidIt> *pointer;

Notes

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

regex_iterator ::reference

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

typedef match_results<BidIt>& reference;

Notes

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

regex_iterator ::regex_iterator

Construit l’itérateur.

regex_iterator();

regex_iterator(BidIt first,
    BidIt last,
    const regex_type& re,
    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 deuxième constructeur initialise la valeur stockée avec la première, la valeur end stockée avec la dernière, la valeur pregex stockée avec &re, et la valeur flags stockée avec f.begin Il appelle ensuite regex_search(begin, end, match, *pregex, flags). En cas d’échec de la recherche, le constructeur assigne à l’objet un itérateur de fin de séquence.

regex_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_iterator ::value_type

Type d'une correspondance.

typedef match_results<BidIt> value_type;

Notes

Le type est un synonyme de match_results<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_token_iterator, classe
regex_traits, classe
<regex> typedefs