regex_token_iterator-Klasse

Iteratorklasse für Teilübereinstimmungen.

Syntax

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

Parameter

BidIt
Der Itertatortyp für Teilübereinstimmungen.

Elem
Der zu entsprechende Elementtyp.

RX-Merkmale
Merkmalklasse für Elemente.

Hinweise

Die Klassenvorlage beschreibt ein Konstantenweiterleitungs-Iteratorobjekt. Vom Konzept her enthält sie ein regex_iterator -Objekt, das in der Klasse verwendet wird, um in einer Zeichenfolge nach Übereinstimmungen eines regulären Ausdrucks zu suchen. In der Klasse werden Objekte des Typs sub_match<BidIt> extrahiert, die den Teilübereinstimmungen entsprechen, die durch die Indexwerte im gespeicherten Vektor subs für jede Übereinstimmung des regulären Ausdrucks gekennzeichnet sind.

Der Indexwert -1 kennzeichnet die Zeichenfolge, die unmittelbar nach dem Ende der vorherigen Übereinstimmung des regulären Ausdrucks oder, wenn es keine vorherige Übereinstimmung eines regulären Ausdrucks gab, am Anfang der Zeichenfolge beginnt und sich, ohne es zu enthalten, bis zum ersten Zeichen der aktuellen Übereinstimmung des regulären Ausdrucks oder bis zum Ende der Zeichenfolge erstreckt, wenn es keine aktuelle Übereinstimmung gibt. Jeder andere Indexwert idx kennzeichnet die Inhalte der Erfassungsgruppe, die in it.match[idx]enthalten ist.

Member

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

Konstruktoren

Konstruktor	Beschreibung
regex_token_iterator	Erstellt den Iterator.

TypeDefs

Typname	Beschreibung
difference_type	Der Typ einer Iteratordifferenz.
iterator_category	Der Typ der Iteratorkategorie.
pointer	Der Typ eines Zeigers auf eine Übereinstimmung.
reference	Der Typ eines Verweises auf eine Teilübereinstimmung.
regex_type	Der Typ des regulären Ausdrucks, der übereinstimmen soll.
value_type	Der Typ einer Teilübereinstimmung.

Operatoren

Operator	Beschreibung
operator!=	Vergleicht Iteratoren auf Ungleichheit.
operator*	Greift auf die gekennzeichnete Teilübereinstimmung zu.
operator++	Erhöht den Iterator.
operator==	Vergleicht Iteratoren auf Gleichheit.
operator->	Greift auf die gekennzeichnete Teilübereinstimmung zu.

Anforderungen

Header:<regex>

Namespace: std

Beispiel

#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

Der Typ einer Iteratordifferenz.

typedef std::ptrdiff_t difference_type;

Hinweise

Der Typ ist ein Synonym für std::ptrdiff_t.

regex_token_iterator::iterator_category

Der Typ der Iteratorkategorie.

typedef std::forward_iterator_tag iterator_category;

Hinweise

Der Typ ist ein Synonym für std::forward_iterator_tag.

regex_token_iterator::operator!=

Vergleicht Iteratoren auf Ungleichheit.

bool operator!=(const regex_token_iterator& right);

Parameter

right
Der Iterator für den Vergleich.

Hinweise

Die Memberfunktion gibt !(*this == right) zurück.

regex_token_iterator::operator*

Greift auf die gekennzeichnete Teilübereinstimmung zu.

const sub_match<BidIt>& operator*();

Hinweise

Die Memberfunktion gibt ein sub_match<BidIt> -Objekt zurück, das der Erfassungsgruppe entspricht, die durch den Indexwert subs[pos]gekennzeichnet ist.

regex_token_iterator::operator++

Erhöht den Iterator.

regex_token_iterator& operator++();

regex_token_iterator& operator++(int);

Hinweise

Wenn der gespeicherte Iterator it ein Iterator am Ende der Sequenz ist, legt der erste Operator den gespeicherten Wert pos auf den Wert von subs.size() fest (wodurch er ein Iterator am Ende der Sequenz wird). Andernfalls erhöht der Operator den gespeicherten Wert pos. Wenn das Ergebnis dem Wert subs.size() entspricht, wird der gespeicherte Wert pos auf 0 (null) festgelegt und der gespeicherte Iterator it wird erhöht. Wenn beim Inkrementieren der gespeicherte Iterator keinem Iterator am Ende der Sequenz entspricht, führt der Operator keine weitere Aktion aus. Andernfalls, wenn das Ende der vorherigen Übereinstimmung sich am Ende der Zeichenfolge befand, legt der Operator den gespeicherten Wert von pos auf subs.size() fest. Andernfalls erhöht der Operator wiederholt den gespeicherten Wert pos bis auf pos == subs.size() oder subs[pos] == -1 (wodurch sichergestellt wird, dass die nächste Dereferenzierung des Iterators das Ende der Zeichenfolge zurückgibt, wenn einer der Indexwerte -1 ist). In allen Fällen gibt der Operator das Objekt zurück.

Der zweite Operator erstellt eine Kopie des Objekts, erhöht das Objekt und gibt dann die Kopie zurück.

regex_token_iterator::operator==

Vergleicht Iteratoren auf Gleichheit.

bool operator==(const regex_token_iterator& right);

Parameter

right
Der Iterator für den Vergleich.

Hinweise

Die Memberfunktion gibt it == right.it && subs == right.subs && pos == right.pos zurück.

regex_token_iterator::operator->

Greift auf die gekennzeichnete Teilübereinstimmung zu.

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

Hinweise

Die Memberfunktion gibt einen Zeiger auf ein sub_match<BidIt> -Objekt zurück, das der Erfassungsgruppe entspricht, die durch den Indexwert subs[pos]gekennzeichnet ist.

regex_token_iterator::p ointer

Der Typ eines Zeigers auf eine Übereinstimmung.

typedef sub_match<BidIt> *pointer;

Hinweise

Der Typ ist ein Synonym für sub_match<BidIt>*, wobei BidIt der Vorlagenparameter ist.

regex_token_iterator::reference

Der Typ eines Verweises auf eine Teilübereinstimmung.

typedef sub_match<BidIt>& reference;

Hinweise

Der Typ ist ein Synonym für sub_match<BidIt>&, wobei BidIt der Vorlagenparameter ist.

regex_token_iterator::regex_token_iterator

Erstellt den Iterator.

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

Parameter

first
Anfang der Sequenz, die übereinstimmen soll.

last
Ende der Sequenz, die übereinstimmen soll.

re
Regulärer Ausdruck für Übereinstimmungen.

f
Flags für Übereinstimmungen.

Hinweise

Der erste Konstruktor erstellt einen Sequenzende-Iterator.

Der zweite Konstruktor erstellt ein Objekt, dessen gespeicherter Iterator it auf regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f)initialisiert wird, dessen gespeicherter Vektor subs genau eine ganze Zahl mit dem Wert submatchenthält und dessen gespeicherter Wert pos gleich 0 (null) ist. Hinweis: Das resultierende Objekt extrahiert für jede erfolgreiche Übereinstimmung des regulären Ausdrucks die Teilübereinstimmung, die durch den Indexwert submatch gekennzeichnet ist.

Der dritte Konstruktor erstellt ein Objekt, dessen gespeicherter Iterator it auf regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f)initialisiert wird, dessen gespeicherter Vektor subs genau eine Kopie des Konstruktorarguments submatchesenthält und dessen gespeicherter Wert pos gleich 0 (null) ist.

Der vierte Konstruktor erstellt ein Objekt, dessen gespeicherter Iterator it auf regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f)initialisiert wird, dessen gespeicherter Vektor subs die N Werte enthält, auf die das Konstruktorargument submatcheszeigt, und dessen gespeicherter Wert pos gleich 0 (null) ist.

regex_token_iterator::regex_type

Der Typ des regulären Ausdrucks, der übereinstimmen soll.

typedef basic_regex<Elem, RXtraits> regex_type;

Hinweise

Die Typedef ist ein Synonym für basic_regex<Elem, RXtraits>.

regex_token_iterator::value_type

Der Typ einer Teilübereinstimmung.

typedef sub_match<BidIt> value_type;

Hinweise

Der Typ ist ein Synonym für sub_match<BidIt>, wobei BidIt der Vorlagenparameter ist.

Siehe auch

<regex>
regex_constants-Klasse
regex_error-Klasse
<regex-Funktionen>
regex_iterator-Klasse
<regex-Operatoren>
regex_traits-Klasse
<regex> typedefs