Classe regex_iterator

Classe de iterador para correspondências.

Sintaxe

template<class BidIt,
   class Elem = typename std::iterator_traits<BidIt>::value_type,
   class RxTraits = regex_traits<Elem> >
class regex_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. Ele extrai objetos do tipo match_results<BidIt> aplicando repetidamente seu objeto de expressão regular *pregex à sequência de caracteres definida pelo intervalo do iterador [begin, end).

Construtores

Typedefs

Operadores

Requisitos

Cabeçalho:<regex>

Namespace: std

Exemplos

Confira os artigos a seguir para ver exemplos de expressões regulares:

• regex_match

• regex_replace

• regex_search

• troca

// 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 tipo_de_experiência

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

Compara a desigualdade dos iteradores.

bool operator!=(const regex_iterator& right);

Parâmetros

direita
O iterador a ser comparado.

Comentários

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

regex_iterator::operador*

Acessa a correspondência designada.

const match_results<BidIt>& operator*();

Comentários

A função do membro retorna o valor armazenado match.

regex_iterator::operador++

Incrementa o iterador.

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

Comentários

Se a correspondência atual não tiver nenhum caractere, o primeiro operador chama regex_search(begin, end, match, *pregex, flags | regex_constants::match_prev_avail | regex_constants::match_not_null); caso contrário, ele avança o valor armazenado begin para apontar para o primeiro caractere após a correspondência atual e chama regex_search(begin, end, match, *pregex, flags | regex_constants::match_prev_avail). Em ambos os casos, se a pesquisa falhar, o operador define o objeto como um iterador de fim de sequência. O operador retorna o objeto.

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

regex_iterator::operator=

Compara a igualdade dos iteradores.

bool operator==(const regex_iterator& right);

Parâmetros

direita
O iterador a ser comparado.

Comentários

A função membro retorna true quando *this e right são iteradores de fim de sequência ou quando nenhum deles é iterador de fim de sequência e begin == right.begin, end == right.end, pregex == right.pregex e flags == right.flags. Caso contrário, retorna false.

regex_iterator::operator->

Acessa a correspondência designada.

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

Comentários

A função membro retorna o endereço do valor armazenado match.

regex_iterator::p ointer

O tipo de um ponteiro para uma correspondência.

typedef match_results<BidIt> *pointer;

Comentários

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

regex_iterator::referência

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

typedef match_results<BidIt>& reference;

Comentários

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

regex_iterator::regex_iterator

Constrói o iterador.

regex_iterator();

regex_iterator(BidIt first,
    BidIt last,
    const regex_type& re,
    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 inicializa o valor armazenado begin com first, o valor armazenado end com last, o valor armazenado pregex com &re e o valor armazenado flags com f. Depois, chama regex_search(begin, end, match, *pregex, flags). Se a pesquisa falhar, o construtor define o objeto como um iterador de fim de sequência.

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

O tipo de uma correspondência.

typedef match_results<BidIt> value_type;

Comentários

O tipo é um sinônimo de match_results<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_token_iterator
Classe regex_traits
<regex> typedefs