regex_token_iterator – třída

Iterátor – třída pro podsložky

Syntaxe

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

Parametry

BidIt
Typ iterátoru pro podsložky.

Elem
Typ prvků, které se mají spárovat.

RXtraits
Třída vlastností prvků.

Poznámky

Šablona třídy popisuje konstantní objekt iterátoru vpřed. Koncepčně obsahuje regex_iterator objekt, který používá k hledání shody regulárního výrazu v sekvenci znaků. Extrahuje objekty typu sub_match<BidIt> představující podsoučty identifikované hodnotami indexu v uloženém vektoru subs pro každou shodu regulárního výrazu.

Hodnota indexu -1 určuje posloupnost znaků, která začíná bezprostředně po konci předchozí shody regulárního výrazu, nebo začíná na začátku sekvence znaků, pokud nebyla nalezena žádná předchozí shoda regulárního výrazu, a rozšiřuje se, ale neobsahuje první znak shody aktuálního regulárního výrazu nebo na konec sekvence znaků, pokud neexistuje žádná aktuální shoda. Jakákoli jiná hodnota idx indexu určuje obsah skupiny zachycení uchovávané v it.match[idx].

Členové

Člen	Výchozí hodnota
private regex_iterator<BidIt, Elem, RXtraits> it
private vector<int> subs
private int pos

Konstruktory

Konstruktor	Popis
regex_token_iterator	Vytvoří iterátor.

Typedefs

Název typu	Popis
difference_type	Typ rozdílu iterátoru.
iterator_category	Typ kategorie iterátoru.
ukazatel	Typ ukazatele na shodu.
odkaz	Typ odkazu na podsložku.
regex_type	Typ regulárního výrazu, který se má shodovat.
value_type	Typ podsoučtu.

Operátory

Operátor	Popis
operator!=	Porovnává iterátory nerovnosti.
operátor*	Přistupuje k určené podmnožině.
operator++	Zvýší iterátor.
operator==	Porovnává iterátory rovnosti.
operátor->	Přistupuje k určené podmnožině.

Požadavky

Header:<regex>

Namespace: std

Příklad

#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

Typ rozdílu iterátoru.

typedef std::ptrdiff_t difference_type;

Poznámky

Typ je synonymem pro std::ptrdiff_t.

regex_token_iterator::iterator_category

Typ kategorie iterátoru.

typedef std::forward_iterator_tag iterator_category;

Poznámky

Typ je synonymem pro std::forward_iterator_tag.

regex_token_iterator::operator!=

Porovnává iterátory nerovnosti.

bool operator!=(const regex_token_iterator& right);

Parametry

Vpravo
Iterátor, který se má porovnat.

Poznámky

Členová funkce vrátí !(*this == right).

regex_token_iterator::operator*

Přistupuje k určené podmnožině.

const sub_match<BidIt>& operator*();

Poznámky

Členová funkce vrátí sub_match<BidIt> objekt představující skupinu zachycení identifikovanou hodnotou subs[pos]indexu .

regex_token_iterator::operator++

Zvýší iterátor.

regex_token_iterator& operator++();

regex_token_iterator& operator++(int);

Poznámky

Pokud je uložený iterátor end-of-sequence iterátor it , první operátor nastaví uloženou hodnotu pos na hodnotu ( subs.size() čímž vytvoří iterátor koncové sekvence). V opačném případě operátor zvýší uloženou hodnotu pos; pokud je výsledek roven hodnotě subs.size() , nastaví uloženou hodnotu pos na nulu a zvýší uložený iterátor it. Pokud inkrementace uloženého iterátoru ponechá nerovný s iterátorem na konci sekvence, operátor nic dalšího neprovede. Jinak pokud byl konec předchozí shody na konci sekvence znaků, operátor nastaví uloženou hodnotu pos na subs.size(). V opačném případě operátor opakovaně zvýší uloženou hodnotu pos do pos == subs.size() nebo subs[pos] == -1 (čímž zajistí, že další dereference iterátoru vrátí konec sekvence znaků, pokud je jedna z hodnot indexu -1). Ve všech případech vrátí operátor objekt.

Druhý operátor vytvoří kopii objektu, zvýší objekt a pak vrátí kopii.

regex_token_iterator::operator==

Porovnává iterátory rovnosti.

bool operator==(const regex_token_iterator& right);

Parametry

Vpravo
Iterátor, který se má porovnat.

Poznámky

Členová funkce vrátí it == right.it && subs == right.subs && pos == right.pos.

regex_token_iterator::operator->

Přistupuje k určené podmnožině.

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

Poznámky

Členová funkce vrátí ukazatel na sub_match<BidIt> objekt představující skupinu zachycení identifikovanou hodnotou subs[pos]indexu .

regex_token_iterator::p ointer

Typ ukazatele na shodu.

typedef sub_match<BidIt> *pointer;

Poznámky

Typ je synonymem pro sub_match<BidIt>*, kde BidIt je parametr šablony.

regex_token_iterator::reference

Typ odkazu na podsložku.

typedef sub_match<BidIt>& reference;

Poznámky

Typ je synonymem pro sub_match<BidIt>&, kde BidIt je parametr šablony.

regex_token_iterator::regex_token_iterator

Vytvoří iterátor.

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

Parametry

první
Začátek sekvence, která se má shodovat.

poslední
Konec sekvence, která se má shodovat.

týká se
Regulární výraz pro shody.

f
Příznaky pro shody.

Poznámky

První konstruktor vytvoří iterátor konce sekvence.

Druhý konstruktor vytvoří objekt, jehož uložený iterátor it je inicializován na regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), jehož uložený vektor subs obsahuje přesně jedno celé číslo, s hodnotou submatcha jehož uložená hodnota pos je nula. Poznámka: Výsledný objekt extrahuje podmatch identifikovaný hodnotou submatch indexu pro každou úspěšnou shodu regulárního výrazu.

Třetí konstruktor vytvoří objekt, jehož uložený iterátor it je inicializován na regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), jehož uložený vektor subs obsahuje kopii argumentu submatcheskonstruktoru , a jehož uložená hodnota pos je nula.

Čtvrtý konstruktor vytvoří objekt, jehož uložený iterátor it je inicializován na regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f), jehož uložený vektor subs obsahuje N hodnoty odkazované argumentem submatcheskonstruktoru a jehož uložená hodnota pos je nula.

regex_token_iterator::regex_type

Typ regulárního výrazu, který se má shodovat.

typedef basic_regex<Elem, RXtraits> regex_type;

Poznámky

Typedef je synonymem pro basic_regex<Elem, RXtraits>.

regex_token_iterator::value_type

Typ podsoučtu.

typedef sub_match<BidIt> value_type;

Poznámky

Typ je synonymem pro sub_match<BidIt>, kde BidIt je parametr šablony.

Viz také

<regex>
regex_constants – třída
regex_error – třída
<funkce regulárních výrazů>
regex_iterator – třída
<Operátory regulárních výrazů>
regex_traits – třída
<regex> typedefs