regex_token_iterator 类

子匹配项的迭代器类。

语法

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

参数

BidIt
子匹配项的迭代器类型。

Elem
要匹配的元素的类型。

RXtraits
元素的特征类。

备注

这个类模板描述常量前向迭代器对象。 从概念上讲,它承载 regex_iterator 对象,并用于搜索字符序列中正则表达式的匹配项。 它提取 sub_match<BidIt> 类型的对象,这些对象表示由每个正则表达式匹配项的存储向量 subs 中的索引值标识的子匹配项。

-1 索引值指定在上一个正则表达式匹配项末尾后立即开始(如果不存在上一个正则表达式匹配项,则为从字符序列的起始处开始)的字符序列,并扩展到但不包含当前正则表达式匹配项的第一个字符(如果不存在当前匹配项,则扩展到字符序列末尾)。 任何其他索引值 idx 指定承载于 it.match[idx]中捕获组的内容。

成员

成员 默认值
private regex_iterator<BidIt, Elem, RXtraits> it
private vector<int> subs
private int pos

构造函数

构造函数 说明
regex_token_iterator 构造迭代器。

Typedef

类型名称 说明
difference_type 迭代器差异的类型。
iterator_category 迭代器类别的类型。
pointer 指向一个匹配的指针的类型。
reference 对子匹配项的引用的类型。
regex_type 要匹配的正则表达式类型。
value_type 子匹配项的类型。

运算符

运算符 说明
operator!= 比较不相等的迭代器。
operator* 访问指定的子匹配项。
operator++ 递增迭代器。
operator== 比较迭代器是否相等。
operator-> 访问指定的子匹配项。

要求

标头:<regex>

命名空间: std

示例

#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::difference_type

迭代器差异的类型。

typedef std::ptrdiff_t difference_type;

注解

类型是 std::ptrdiff_t 的同义词。

regex_token_iterator::iterator_category

迭代器类别的类型。

typedef std::forward_iterator_tag iterator_category;

注解

类型是 std::forward_iterator_tag 的同义词。

regex_token_iterator::operator!=

比较不相等的迭代器。

bool operator!=(const regex_token_iterator& right);

参数

right
要进行比较的迭代器。

备注

成员函数返回 !(*this == right)

regex_token_iterator::operator*

访问指定的子匹配项。

const sub_match<BidIt>& operator*();

注解

成员函数返回一个 sub_match<BidIt> 对象,该对象表示由索引值 subs[pos]标识的捕获组。

regex_token_iterator::operator++

递增迭代器。

regex_token_iterator& operator++();

regex_token_iterator& operator++(int);

备注

如果存储的迭代器 it 是序列末尾迭代器,则第一个运算符将存储的值 pos 设置为 subs.size() 的值(从而生成序列末尾迭代器)。 否则,运算符递增存储的值 pos;如果结果等于值 subs.size(),则它将存储的值 pos 设置为零,并递增存储的迭代器 it。 如果递增存储的迭代器让它不等于序列结尾迭代器,则运算符不会进一步执行操作。 否则,如果前面匹配项的结尾位于字符序列的结尾,则运算符将 pos 的存储的值设置为 subs.size()。 否则,运算符重复递增存储的值 pos,直到 pos == subs.size()subs[pos] == -1(从而确保其中一个索引值为 -1 时,迭代器的下一次取消引用将返回字符序列的结尾)。 在所有情况下,运算符都会返回对象。

第二个运算符生成对象的副本,递增对象,然后返回副本。

regex_token_iterator::operator==

比较迭代器是否相等。

bool operator==(const regex_token_iterator& right);

参数

right
要进行比较的迭代器。

备注

成员函数返回 it == right.it && subs == right.subs && pos == right.pos

regex_token_iterator::operator->

访问指定的子匹配项。

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

注解

成员函数返回一个指向 sub_match<BidIt> 对象的指针,该对象表示由索引值 subs[pos]标识的捕获组。

regex_token_iterator::pointer

指向一个匹配的指针的类型。

typedef sub_match<BidIt> *pointer;

备注

类型是 sub_match<BidIt>* 的同义词,其中 BidIt 是模板参数。

regex_token_iterator::reference

对子匹配项的引用的类型。

typedef sub_match<BidIt>& reference;

备注

类型是 sub_match<BidIt>& 的同义词,其中 BidIt 是模板参数。

regex_token_iterator::regex_token_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);

参数

first
要匹配的序列的开头。

last
要匹配的序列的结尾。

re
匹配项正则表达式。

f
匹配标志。

备注

第一个构造函数将构造序列末迭代器。

第二个构造函数将构造一个对象,其存储的迭代器 it 初始化为 regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f),其存储的向量 subs 承载恰好一个整数(值为 submatch),并且其存储的值 pos 为零。 注意:对于每个成功的正则表达式匹配项,生成的对象将提取由索引值 submatch 标识的子匹配项。

第三个构造函数将构造一个对象,其存储的迭代器 it 初始化为 regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f),其存储的向量 subs 承载构造函数参数 submatches的一个副本,并且其存储的值 pos 为零。

第四个构造函数将构造一个对象,其存储的迭代器 it 初始化为 regex_iterator<BidIt, Elem, RXtraits>(first, last, re, f),其存储的向量 subs 承载构造函数参数 N 指向的 submatches值,并且其存储的值 pos 为零。

regex_token_iterator::regex_type

要匹配的正则表达式类型。

typedef basic_regex<Elem, RXtraits> regex_type;

备注

typedef 是 basic_regex<Elem, RXtraits>的同义词。

regex_token_iterator::value_type

子匹配项的类型。

typedef sub_match<BidIt> value_type;

备注

类型是 sub_match<BidIt> 的同义词,其中 BidIt 是模板参数。

另请参阅

<regex>
regex_constants 类
regex_error 类
<regex> 函数
regex_iterator 类
<regex> 运算符
regex_traits 类
<regex> typedefs