Classe regex_token_iterator

Classe de iterador para subcorrespondências.

Sintaxe

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

Parâmetros

BidIt
O tipo de iterador para subcorrespondências.

Elem
O tipo de elemento a ser correspondido.

RXtraits
Classe de características para elementos.

Comentários

O modelo de classe descreve um objeto iterador de encaminhamento constante. Conceitualmente, ela mantém um objeto regex_iterator que utiliza para pesquisar correspondências de expressão regular em uma sequência de caracteres. Ela extrai objetos do tipo sub_match<BidIt> representando as subcorrespondências identificadas pelos valores de índice no vetor armazenado subs para cada correspondência de expressão regular.

Um valor de -1 designa a sequência de caracteres que começa imediatamente após o fim da correspondência de expressão regular anterior ou que começa no início da sequência de caracteres, se não houver nenhuma correspondência de expressão regular anterior e estendendo-se a, sem incluir, o primeiro caractere da correspondência da expressão regular ou até o fim da sequência de caracteres se não houver nenhuma correspondência atual. Qualquer outro valor de índice idx designa o conteúdo do grupo de captura mantido em it.match[idx].

Membros

Membro	Valor Padrão
private regex_iterator<BidIt, Elem, RXtraits> it
private vector<int> subs
private int pos

Construtores

Construtor	Descrição
regex_token_iterator	Constrói o iterador.

Typedefs

Nome do tipo	Descrição
difference_type	O tipo de uma diferença de iterador.
iterator_category	O tipo da categoria do iterador.
pointer	O tipo de um ponteiro para uma correspondência.
referência	O tipo de uma referência de uma subcorrespondência.
regex_type	O tipo da expressão regular de correspondência.
value_type	O tipo de uma subcorrespondência.

Operadores

Operador	Descrição
operator!=	Compara a desigualdade dos iteradores.
operator*	Acessa a subcorrespondência designada.
operador++	Incrementa o iterador.
operator==	Compara a igualdade dos iteradores.
operator->	Acessa a subcorrespondência designada.

Requisitos

Cabeçalho:<regex>

Namespace: std

Exemplo

#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 tipo_de_diferenciação

O tipo de uma diferença de iterador.

typedef std::ptrdiff_t difference_type;

Comentários

O tipo é um sinônimo de std::ptrdiff_t.

regex_token_iterator::iterator_category

O tipo da categoria do iterador.

typedef std::forward_iterator_tag iterator_category;

Comentários

O tipo é um sinônimo de std::forward_iterator_tag.

regex_token_iterator::operador!=

Compara a desigualdade dos iteradores.

bool operator!=(const regex_token_iterator& right);

Parâmetros

direita
O iterador a ser comparado.

Comentários

A função membro retorna !(*this == right).

regex_token_iterator::operador*

Acessa a subcorrespondência designada.

const sub_match<BidIt>& operator*();

Comentários

A função de membro retorna um objeto sub_match<BidIt> que representa o grupo de captura identificado pelo valor de índice subs[pos].

regex_token_iterator::operador++

Incrementa o iterador.

regex_token_iterator& operator++();

regex_token_iterator& operator++(int);

Comentários

Se o iterador armazenado it for um iterador de fim-de-sequência, o primeiro operador define o valor armazenado pos para o valor de subs.size() (criando dessa forma um iterador de fim de sequência). Caso contrário, o operador incrementa o valor armazenado pos; se o resultado for igual ao valor subs.size(), ela define o valor armazenado pos como zero e incrementa o iterador armazenado it. Ao incrementar, o iterador armazenado deixa-os diferentes de um iterador de fim de sequência e o operador não fará nada mais. Caso contrário, se o final da correspondência anterior estava no fim da sequência de caracteres, o operador define o valor armazenado de pos para subs.size(). Caso contrário, o operador repetidamente incrementa o valor armazenado pos até pos == subs.size() ou subs[pos] == -1 (garantindo, assim, que a próxima desreferência do iterador retornará o final da sequência de caracteres se um dos valores de índice for -1). Em todo caso, o operador retorna o objeto.

O segundo operador faz uma cópia do objeto, incrementa o objeto e retorna a cópia.

regex_token_iterator::operador==

Compara a igualdade dos iteradores.

bool operator==(const regex_token_iterator& right);

Parâmetros

direita
O iterador a ser comparado.

Comentários

A função membro retorna it == right.it && subs == right.subs && pos == right.pos.

regex_token_iterator::operator->

Acessa a subcorrespondência designada.

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

Comentários

A função membro retorna um ponteiro para um objeto sub_match<BidIt> que representa o grupo de captura identificado pelo valor do índice subs[pos].

regex_token_iterator::p ointer

O tipo de um ponteiro para uma correspondência.

typedef sub_match<BidIt> *pointer;

Comentários

O tipo é um sinônimo de sub_match<BidIt>*, em que BidIt é o parâmetro de modelo.

regex_token_iterator::referência

O tipo de uma referência de uma subcorrespondência.

typedef sub_match<BidIt>& reference;

Comentários

O tipo é um sinônimo de sub_match<BidIt>&, em que BidIt é o parâmetro de modelo.

regex_token_iterator::regex_token_iterator

Constrói o 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
Início da sequência de correspondência.

last
Fim da sequência de correspondência.

re
Expressão regular para correspondências.

f
Sinalizadores de correspondências.

Comentários

O primeiro construtor cria um iterador de fim de sequência.

O segundo construtor cria um objeto cujo iterador armazenado it é inicializado com regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), cujo vetor armazenado subs contém exatamente um inteiro, com valor submatch e cujo valor armazenado pos é zero. Observação: o objeto resultante extrai a subcorrespondência identificada pelo valor de índice submatch para cada correspondência de expressão regular bem-sucedida.

O terceiro construtor cria um objeto cujo iterador armazenado it é inicializado para regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), cujo vetor armazenado subs mantém uma cópia do argumento do construtor submatches e cujo valor armazenado pos é zero.

O quarto construtor cria um objeto cujo iterador armazenado it é inicializado para regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), cujo vetor armazenado subs mantém os valores N apontados pelo argumento do construtor submatches e cujo valor armazenado pos é zero.

regex_token_iterator::regex_type

O tipo da expressão regular de correspondência.

typedef basic_regex<Elem, RXtraits> regex_type;

Comentários

O typedef é um sinônimo de basic_regex<Elem, RXtraits>.

regex_token_iterator::value_type

O tipo de uma subcorrespondência.

typedef sub_match<BidIt> value_type;

Comentários

O tipo é um sinônimo de sub_match<BidIt>, em que BidIt é o parâmetro de modelo.

Confira também

<regex>
Classe regex_constants
Classe regex_error
Funções <regex>
Classe regex_iterator
Operadores <regex>
Classe regex_traits
<regex> typedefs