regex_token_iterator (Clase)

Clase de iterador para subcoincidencias.

Sintaxis

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

Parámetros

BidIt
El tipo de iterador para subcoincidencias.

Elem
Tipo de los elementos que debe coincidir.

RXtraits
Clase Traits para los elementos.

Comentarios

La plantilla de clase describe un objeto constante de iterador hacia delante. Conceptualmente, contiene un objeto regex_iterator que usa para buscar coincidencias de expresiones regulares en una secuencia de caracteres. Extrae objetos del tipo sub_match<BidIt> que representan las subcoincidencias identificadas por los valores de índice en el vector almacenado subs para cada coincidencia de expresión regular.

Un valor de índice de -1 señala la secuencia de caracteres que empieza inmediatamente después del final de la coincidencia de expresión regular anterior (o comienza al principio de la secuencia de caracteres si no había ninguna coincidencia de expresión regular anterior) y que se extiende, aunque sin incluirlo, al primer carácter de la coincidencia de expresión regular actual o hasta el final de la secuencia de caracteres si no hay una coincidencia actual. Cualquier otro valor de índice idx señala el contenido del grupo de capturas incluido en it.match[idx].

Miembros

Member	Valor predeterminado
private regex_iterator<BidIt, Elem, RXtraits> it
private vector<int> subs
private int pos

Constructores

Constructor	Descripción
regex_token_iterator	Construye el iterador.

Typedefs

Nombre de tipo	Descripción
difference_type	El tipo de diferencia de un iterador.
iterator_category	Tipo de la categoría del iterador.
pointer	El tipo de un puntero a una coincidencia.
referencia	El tipo de una referencia a una subcoincidencia.
regex_type	El tipo de expresión regular que debe coincidir.
value_type	El tipo de una subcoincidencia.

Operadores

Operador	Descripción
operator!=	Compara iteradores para buscar desigualdad.
operator*	Tiene acceso a la subcoincidencia designada.
operator++	Incrementa el iterador almacenado.
operator==	Compara iteradores para buscar igualdad.
operator->	Tiene acceso a la subcoincidencia designada.

Requisitos

Encabezado:<regex>

Espacio de nombres: std

Ejemplo

#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

El tipo de diferencia de un iterador.

typedef std::ptrdiff_t difference_type;

Comentarios

El tipo es un sinónimo de std::ptrdiff_t.

regex_token_iterator::iterator_category

Tipo de la categoría del iterador.

typedef std::forward_iterator_tag iterator_category;

Comentarios

El tipo es un sinónimo de std::forward_iterator_tag.

regex_token_iterator::operator!=

Compara iteradores para buscar desigualdad.

bool operator!=(const regex_token_iterator& right);

Parámetros

right
Iterador con el que se compara.

Comentarios

La función miembro devuelve !(*this == right).

regex_token_iterator::operator*

Tiene acceso a la subcoincidencia designada.

const sub_match<BidIt>& operator*();

Comentarios

La función miembro devuelve un objeto sub_match<BidIt> que representa el grupo de capturas identificado por el valor de índice subs[pos].

regex_token_iterator::operator++

Incrementa el iterador almacenado.

regex_token_iterator& operator++();

regex_token_iterator& operator++(int);

Comentarios

Si el iterador almacenado it es un iterador de final de secuencia, el primer operador establece el valor almacenado pos en el valor de subs.size() (lo que lo convierte en un iterador de fin de secuencia). En caso contrario, el operador incrementa el valor almacenado pos; si el resultado es igual al valor subs.size(), establece el valor almacenado pos en cero e incrementa el iterador almacenado it. Si al incrementar el iterador almacenado no queda igual que un iterador de final de secuencia, el operador no hace nada más. De lo contrario, si el final de la coincidencia precedente no estaba al final de la secuencia de caracteres, el operador establece el valor almacenado de pos en subs.size(). De lo contrario, el operador incrementa repetidamente el valor almacenado pos hasta pos == subs.size() o subs[pos] == -1 (lo que garantiza que la siguiente desreferencia del iterador devolverá el final de la secuencia de caracteres si uno de los valores de índice es -1). En todos los casos, el operador devuelve el objeto.

El segundo operador realiza una copia del objeto, incrementa el objeto y devuelve la copia.

regex_token_iterator::operator==

Compara iteradores para buscar igualdad.

bool operator==(const regex_token_iterator& right);

Parámetros

right
Iterador con el que se compara.

Comentarios

La función miembro devuelve it == right.it && subs == right.subs && pos == right.pos.

regex_token_iterator::operator->

Tiene acceso a la subcoincidencia designada.

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

Comentarios

La función miembro devuelve un puntero al objeto sub_match<BidIt> que representa el grupo de capturas identificado por el valor de índice subs[pos].

regex_token_iterator::p ointer

El tipo de un puntero a una coincidencia.

typedef sub_match<BidIt> *pointer;

Comentarios

El tipo es un sinónimo de sub_match<BidIt>*, donde BidIt es el parámetro de plantilla.

regex_token_iterator::reference

El tipo de una referencia a una subcoincidencia.

typedef sub_match<BidIt>& reference;

Comentarios

El tipo es un sinónimo de sub_match<BidIt>&, donde BidIt es el parámetro de plantilla.

regex_token_iterator::regex_token_iterator

Construye el iterador.

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

Parámetros

first
Principio de la secuencia que debe coincidir.

last
Final de la secuencia que debe coincidir.

re
Expresión regular para las coincidencias.

f
Marcadores para coincidencias.

Comentarios

El primer constructor crea un iterador de final de secuencia.

El segundo constructor crea un objeto cuyo iterador almacenado it se inicializa en regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), cuyo vector almacenado subs contiene exactamente un número entero, con el valor submatch, y cuyo valor almacenado pos es cero. Nota: el objeto resultante extrae la subcoincidencia identificada por el valor de índice submatch por cada coincidencia de expresión regular correcta.

El tercer constructor crea un objeto cuyo iterador almacenado it se inicializa en regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), cuyo vector almacenado subs contiene una copia del argumento submatchesde constructor y cuyo valor almacenado pos es cero.

El cuarto constructor crea un objeto cuyo iterador almacenado it se inicializa en regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), cuyo vector almacenado subs contiene los valores de N señalados por el argumento submatchesde constructor y cuyo valor almacenado pos es cero.

regex_token_iterator::regex_type

El tipo de expresión regular que debe coincidir.

typedef basic_regex<Elem, RXtraits> regex_type;

Comentarios

La definición de tipo es un sinónimo de basic_regex<Elem, RXtraits>.

regex_token_iterator::value_type

El tipo de una subcoincidencia.

typedef sub_match<BidIt> value_type;

Comentarios

El tipo es un sinónimo de sub_match<BidIt>, donde BidIt es el parámetro de plantilla.

Consulte también

<regex>
regex_constants (Clase)
regex_error (Clase)
<regex> functions
regex_iterator (Clase)
<regex> operators
regex_traits (Clase)
<regex> typedefs