Classe regex_token_iterator

Classe iterator per le sottocorrispondenze.

Sintassi

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

Parametri

BidIt
Tipo di iteratore per le sottocorrispondenze.

Elem
Tipo di elementi di cui trovare una corrispondenza.

RXtraits
Classe traits per gli elementi.

Osservazioni:

Il modello di classe descrive un oggetto iteratore in avanti costante. Concettualmente, contiene un oggetto regex_iterator usato per eseguire la ricerca di corrispondenze di espressione regolare in una sequenza di caratteri. Estrae gli oggetti di tipo sub_match<BidIt> che rappresentano le sottocorrispondenze identificate dai valori di indice nel vettore archiviato subs per ogni corrispondenza di espressione regolare.

Un valore di indice di -1 indica la sequenza di caratteri che comincia subito dopo la fine della precedente corrispondenza di espressione regolare o all'inizio della sequenza di caratteri se non esisteva alcuna corrispondenza di espressione regolare precedente e che si estende, senza includerlo, al primo carattere della corrispondenza di espressione regolare corrente o alla fine della sequenza di caratteri se non esiste alcuna corrispondenza corrente. Qualsiasi altro valore di indice idx definisce il contenuto del gruppo Capture contenuto in it.match[idx].

Membri

Membro	Valore predefinito
private regex_iterator<BidIt, Elem, RXtraits> it
private vector<int> subs
private int pos

Costruttori

Costruttore	Descrizione
regex_token_iterator	Costruisce l'iteratore.

Typedef

Nome tipo	Descrizione
difference_type	Tipo di differenza iteratore.
iterator_category	Tipo della categoria di iteratore.
pointer	Tipo di un puntatore a una corrispondenza.
reference	Tipo di un riferimento a una sottocorrispondenza.
regex_type	Tipo dell'espressione regolare per cui cercare una corrispondenza.
value_type	Tipo di una sottocorrispondenza.

Operatori

Operatore	Descrizione
operator!=	Confronta gli iteratori per verificarne la disuguaglianza.
operator*	Accede alla sottocorrispondenza designata.
operator++	Incrementa l'iteratore.
operator==	Confronta gli iteratori per verificarne l'uguaglianza.
operator->	Accede alla sottocorrispondenza designata.

Requisiti

Header:<regex>

Spazio dei nomi: std

Esempio

#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

Tipo di differenza iteratore.

typedef std::ptrdiff_t difference_type;

Osservazioni:

Il tipo è sinonimo di std::ptrdiff_t.

regex_token_iterator::iterator_category

Tipo della categoria di iteratore.

typedef std::forward_iterator_tag iterator_category;

Osservazioni:

Il tipo è sinonimo di std::forward_iterator_tag.

regex_token_iterator::operator!=

Confronta gli iteratori per verificarne la disuguaglianza.

bool operator!=(const regex_token_iterator& right);

Parametri

right
Iteratore per il confronto.

Osservazioni:

La funzione membro restituisce!(*this == right).

regex_token_iterator::operator*

Accede alla sottocorrispondenza designata.

const sub_match<BidIt>& operator*();

Osservazioni:

La funzione membro restituisce un oggetto sub_match<BidIt> che rappresenta il gruppo Capture identificato dal valore di indice subs[pos].

regex_token_iterator::operator++

Incrementa l'iteratore.

regex_token_iterator& operator++();

regex_token_iterator& operator++(int);

Osservazioni:

Se l'iteratore archiviato it è un iteratore di fine di sequenza, il primo operatore imposta il valore archiviato pos al valore di subs.size() (creando in tal modo un iteratore di fine di sequenza). In caso contrario l'operatore incrementa il valore archiviato pos; se il risultato è uguale al valore subs.size(), imposta il valore archiviato pos su zero e incrementa l'iteratore archiviato it. Se nonostante l'incremento l'iteratore archiviato resta diverso da un iteratore di fine di sequenza, l'operatore non esegue altre operazioni. In caso contrario, se la fine della corrispondenza precedente fosse alla fine della sequenza di caratteri l'operatore, imposta il valore archiviato di pos su subs.size(). Diversamente, l'operatore incrementa ripetutamente il valore archiviato pos fino a pos == subs.size() o subs[pos] == -1; in tal modo la successiva dereferenziazione dell'iteratore restituirà la parte finale della sequenza di caratteri se uno dei valori di indice è -1. In tutti i casi l'operatore restituisce l'oggetto.

Il secondo operatore esegue una copia dell'oggetto, incrementa l'oggetto, quindi restituisce la copia.

regex_token_iterator::operator==

Confronta gli iteratori per verificarne l'uguaglianza.

bool operator==(const regex_token_iterator& right);

Parametri

right
Iteratore per il confronto.

Osservazioni:

La funzione membro restituisceit == right.it && subs == right.subs && pos == right.pos.

regex_token_iterator::operator->

Accede alla sottocorrispondenza designata.

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

Osservazioni:

La funzione membro restituisce un puntatore a un oggetto sub_match<BidIt> che rappresenta il gruppo Capture identificato dal valore di indice subs[pos].

regex_token_iterator::p ointer

Tipo di un puntatore a una corrispondenza.

typedef sub_match<BidIt> *pointer;

Osservazioni:

Il tipo è un sinonimo di sub_match<BidIt>*, dove BidIt è il parametro di modello.

regex_token_iterator::reference

Tipo di un riferimento a una sottocorrispondenza.

typedef sub_match<BidIt>& reference;

Osservazioni:

Il tipo è un sinonimo di sub_match<BidIt>&, dove BidIt è il parametro di modello.

regex_token_iterator::regex_token_iterator

Costruisce l'iteratore.

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);

Parametri

first
Inizio della sequenza per cui cercare una corrispondenza.

last
Fine della sequenza per cui cercare una corrispondenza.

ri
Espressione regolare per le corrispondenze.

f
Flag per le corrispondenze.

Osservazioni:

Il primo costruttore crea un iteratore di fine sequenza.

Il secondo costruttore crea un oggetto il cui iteratore archiviato it viene inizializzato in regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), il cui vettore archiviato subs contiene esattamente un Integer, con valore submatche il cui valore archiviato pos è zero. Nota: l'oggetto risultante estrae la sottocorrispondenza identificata dal valore di indice submatch per ogni corrispondenza dell'espressione regolare con esito positivo.

Il terzo costruttore crea un oggetto il cui iteratore archiviato it viene inizializzato in regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), il cui vettore archiviato subs contiene una copia dell'argomento del costruttore submatchese il cui valore archiviato pos è zero.

Il quarto costruttore crea un oggetto il cui iteratore archiviato it viene inizializzato in regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), il cui vettore archiviato subs contiene i valori N a cui fa riferimento l'argomento del costruttore submatchese il cui valore archiviato pos è zero.

regex_token_iterator::regex_type

Tipo dell'espressione regolare per cui cercare una corrispondenza.

typedef basic_regex<Elem, RXtraits> regex_type;

Osservazioni:

typedef è sinonimo di basic_regex<Elem, RXtraits>.

regex_token_iterator::value_type

Tipo di una sottocorrispondenza.

typedef sub_match<BidIt> value_type;

Osservazioni:

Il tipo è un sinonimo di sub_match<BidIt>, dove BidIt è il parametro di modello.

Vedi anche

<regex>
Classe regex_constants
Classe regex_error
<funzioni regex>
Classe regex_iterator
<Operatori regex>
Classe regex_traits
<typedef regex>