通过

match_results 类

  • 项目

包含一系列子匹配项。

语法

template <class BidIt, class Alloc>
class match_results

参数

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

Alloc
用于管理存储的分配器的类型。

注解

类模板描述一个对象，该对象用于控制由正则表达式搜索生成的 sub_match<BidIt> 类型元素不可修改的序列。 每个元素指向与该元素对应的捕获组匹配的子序列。

构造函数

构造函数 说明
match_results 构造 对象。

Typedef

类型名称 说明
allocator_type 用于管理存储的分配器的类型。
char_type 元素的类型。
const_iterator 子匹配项的常量迭代器类型。
const_reference 元素常量引用的类型。
difference_type 迭代器差异的类型。
iterator 子匹配项的迭代器类型。
reference 元素引用的类型。
size_type 子匹配项计数的类型。
string_type 字符串的类型。
value_type 子匹配项的类型。

成员函数

成员函数 说明
begin 指定子匹配序列的开头。
empty 测试是否无子匹配项。
end 指定子匹配序列的末尾。
format 设置子匹配项格式。
get_allocator 返回存储的分配器。
length 返回子匹配项的长度。
max_size 获取子匹配项的最大数目。
position 获取子组的起始偏移量。
prefix 获取第一个子匹配项之前的序列。
size 计算子匹配项的数目。
str 返回子匹配项。
suffix 获取最后一个子匹配项后的序列。
swap 交换两个 match_results 对象。

运算符

运算符 说明
operator= 复制 match_results 对象。
operator[] 访问子对象。

要求

标头：<regex>

命名空间： std

示例

// std__regex__match_results.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>

int main()
{
    std::regex rx("c(a*)|(b)");
    std::cmatch mr;

    std::regex_search("xcaaay", mr, rx);

    std::cout << "prefix: matched == " << std::boolalpha
        << mr.prefix().matched
        << ", value == " << mr.prefix() << std::endl;
    std::cout << "whole match: " << mr.length() << " chars, value == "
        << mr.str() << std::endl;
    std::cout << "suffix: matched == " << std::boolalpha
        << mr.suffix().matched
        << ", value == " << mr.suffix() << std::endl;
    std::cout << std::endl;

    std::string fmt("\"c(a*)|(b)\" matched \"$&\"\n"
        "\"(a*)\" matched \"$1\"\n"
        "\"(b)\" matched \"$2\"\n");
    std::cout << mr.format(fmt) << std::endl;
    std::cout << std::endl;

    // index through submatches
    for (size_t n = 0; n < mr.size(); ++n)
    {
        std::cout << "submatch[" << n << "]: matched == " << std::boolalpha
            << mr[n].matched <<
            " at position " << mr.position(n) << std::endl;
        std::cout << "  " << mr.length(n)
            << " chars, value == " << mr[n] << std::endl;
    }
    std::cout << std::endl;

    // iterate through submatches
    for (std::cmatch::iterator it = mr.begin(); it != mr.end(); ++it)
    {
        std::cout << "next submatch: matched == " << std::boolalpha
            << it->matched << std::endl;
        std::cout << "  " << it->length()
            << " chars, value == " << *it << std::endl;
    }
    std::cout << std::endl;

    // other members
    std::cout << "empty == " << std::boolalpha << mr.empty() << std::endl;

    std::cmatch::allocator_type al = mr.get_allocator();
    std::cmatch::string_type str = std::string("x");
    std::cmatch::size_type maxsiz = mr.max_size();
    std::cmatch::char_type ch = 'x';
    std::cmatch::difference_type dif = mr.begin() - mr.end();
    std::cmatch::const_iterator cit = mr.begin();
    std::cmatch::value_type val = *cit;
    std::cmatch::const_reference cref = val;
    std::cmatch::reference ref = val;

    maxsiz = maxsiz;  // to quiet "unused" warnings
    if (ref == cref)
        ch = ch;
    dif = dif;

    return (0);
}

prefix: matched == true, value == x
whole match: 4 chars, value == caaa
suffix: matched == true, value == y

"c(a*)|(b)" matched "caaa"
"(a*)" matched "aaa"
"(b)" matched ""

submatch[0]: matched == true at position 1
  4 chars, value == caaa
submatch[1]: matched == true at position 2
  3 chars, value == aaa
submatch[2]: matched == false at position 6
  0 chars, value ==

next submatch: matched == true
  4 chars, value == caaa
next submatch: matched == true
  3 chars, value == aaa
next submatch: matched == false
  0 chars, value ==

empty == false

match_results::allocator_type

用于管理存储的分配器的类型。

typedef Alloc allocator_type;

备注

Typedef 是模板参数 Alloc 的同义词。

match_results::begin

指定子匹配序列的开头。

const_iterator begin() const;

备注

该成员函数返回一个随机访问迭代器，指向序列的第一个元素（或刚超出空序列末尾的位置）。

match_results::char_type

元素的类型。

typedef typename iterator_traits<BidIt>::value_type char_type;

注解

typedef 是类型 iterator_traits<BidIt>::value_type的同义词，后者是被搜索字符序列的元素类型。

match_results::const_iterator

子匹配项的常量迭代器类型。

typedef T0 const_iterator;

注解

该 typedef 描述可用作受控序列的常量随机访问迭代器的对象。

match_results::const_reference

元素常量引用的类型。

typedef const typename Alloc::const_reference const_reference;

注解

typedef 将可作为常量引用的对象描述为受控序列中的元素。

match_results::difference_type

迭代器差异的类型。

typedef typename iterator_traits<BidIt>::difference_type difference_type;

注解

Typedef 是 iterator_traits<BidIt>::difference_type类型的同义词，它描述一个对象，该对象表示任何两个指向受控序列元素的迭代器之间的差异。

match_results::empty

测试是否无子匹配项。

bool empty() const;

注解

仅当正则表达式搜索失败时，该成员函数才返回 true。

match_results::end

指定子匹配序列的末尾。

const_iterator end() const;

备注

成员函数返回一个迭代器，该迭代器指向刚刚超出的序列的末尾。

match_results::format

设置子匹配项格式。

template <class OutIt>
OutIt format(OutIt out,
    const string_type& fmt, match_flag_type flags = format_default) const;

string_type format(const string_type& fmt, match_flag_type flags = format_default) const;

参数

OutIt
输出迭代器类型。

out
要写入到的输出流。

fmt
格式字符串。

flags
格式标志。

备注

每个成员函数在 fmt 格式的控制下生成带格式的文本。 第一个成员函数将带格式的文本写入到其参数 out 定义的序列，并返回 out。第二个成员函数返回保存了带格式文本的副本的字符串对象。

生成格式化文本。 格式字符串中的文字文本通常会复制到目标序列。 格式字符串中的每个转义序列均由它表示的文本替换。 复制和替换的详细信息由传递到函数的格式标志控制。

match_results::get_allocator

返回存储的分配器。

allocator_type get_allocator() const;

备注

成员函数返回 *this 使用的分配器对象的副本以分配其 sub_match 对象。

match_results::iterator

子匹配项的迭代器类型。

typedef const_iterator iterator;

注解

该类型描述可用作受控序列的随机访问迭代器的对象。

match_results::length

返回子匹配项的长度。

difference_type length(size_type sub = 0) const;

参数

sub
子匹配项的索引。

备注

成员函数返回 (*this)[sub].length()。

match_results::match_results

构造 对象。

explicit match_results(const Alloc& alloc = Alloc());

match_results(const match_results& right);

参数

alloc
要存储的分配器对象。

right
要复制的 match_results 对象。

注解

第一个构造函数构造 match_results 对象，其中不包含子匹配项。 第二个构造函数构造 match_results 对象，它是 right 的副本。

match_results::max_size

获取子匹配项的最大数目。

size_type max_size() const;

备注

该成员函数将返回对象可控制的最长序列的长度。

match_results::operator=

复制 match_results 对象。

match_results& operator=(const match_results& right);

参数

right
要复制的 match_results 对象。

备注

成员运算符使用 right 控制的序列的副本替换 *this 控制的序列。

match_results::operator[]

访问子对象。

const_reference operator[](size_type n) const;

参数

n
子匹配项的索引。

注解

该成员函数将返回对受控序列中元素 n 的引用，如果 size() <= n，或捕获组 n 不是匹配项的一部分，则返回对空 sub_match 对象的引用。

match_results::position

获取子组的起始偏移量。

difference_type position(size_type sub = 0) const;

参数

sub
子匹配项的索引。

备注

成员函数将返回 std::distance(prefix().first, (*this)[sub].first)，即目标序列中的第一个字符到受控序列的 n 元素指向的子匹配项中的第一个字符之间的距离。

match_results::prefix

获取第一个子匹配项之前的序列。

const_reference prefix() const;

备注

成员函数会返回一个对类型 sub_match<BidIt> 的对象的引用，它指向始于目标序列开始处并止于 (*this)[0].first的字符序列，也即，它指向匹配的子序列之前的文本。

match_results::reference

元素引用的类型。

typedef const_reference reference;

备注

该类型是类型 const_reference的同义词。

match_results::size

计算子匹配项的数目。

size_type size() const;

备注

该成员函数将返回比用于搜索的正则表达式中捕获组大一的数字，或如果为进行搜索则返回 0。

match_results::size_type

子匹配项计数的类型。

typedef typename Alloc::size_type size_type;

备注

该类型是类型 Alloc::size_type的同义词。

match_results::str

返回子匹配项。

string_type str(size_type sub = 0) const;

参数

sub
子匹配项的索引。

备注

成员函数返回 string_type((*this)[sub])。

match_results::string_type

字符串的类型。

typedef basic_string<char_type> string_type;

备注

该类型是类型 basic_string<char_type>的同义词。

match_results::suffix

获取最后一个子匹配项后的序列。

const_reference suffix() const;

备注

该成员函数将返回对指向起始于 sub_match<BidIt> 、结束于目标序列（即指向匹配序列之后的文本）的 (*this)[size() - 1].second 类型对象的引用。

match_results::swap

交换两个 match_results 对象。

void swap(const match_results& right) throw();

参数

right
要交换的 match_results 对象。

备注

该成员函数定时交换 *this 和 right 的内容且不引发异常。

match_results::value_type

子匹配项的类型。

typedef sub_match<BidIt> value_type;

备注

typedef 是类型 sub_match<BidIt>的同义词。

另请参阅

<regex>