regex_token_iterator 类

项目
10/15/2023

子匹配项的迭代器类。

语法

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

通过