通过

basic_regex 类

  • 项目

包装正则表达式。

语法

template <class Elem, class RXtraits>
class basic_regex

参数

Elem
要匹配的元素的类型。

RXtraits
元素的特征类。

备注

这个类模板描述包含正则表达式的对象。 这个类模板的对象可以传递给模板函数 regex_match、regex_search 和 regex_replace。 它还传递合适的文本字符串自变量，以搜索与正则表达式匹配的文本。 这个类模板有两个专用化，包括针对 char 类型元素的类型定义 regex，以及针对 wchar_t 类型元素的类型定义 wregex。

模板自变量 RXtraits 描述这个类模板支持的正则表达式语法的各个重要属性。 一个指定这些正则表达式特征的外部接口必须与类型为 regex_traits 类的对象相同的类。

某些函数使用操作数序列来定义正则表达式。 可以通过多种方式指定此操作数序列：

ptr：从 ptr（不能为 null 指针）开始、以 null 结尾的序列（例如 C 字符串，用于 char 类型的 Elem），其中结尾元素为值 value_type()，且不是操作数序列的一部分

ptr、count：从 ptr（不能为空指针）开始的 count 元素序列

str：basic_string 对象 str 指定的序列

first、last：范围 [first, last) 中由迭代器 first 和 last 分隔的元素序列

right：basic_regex 对象 right

以上成员函数还使用自变量 flags 指定用于解释正则表达式的各个选项以及 RXtraits 类型描述的选项。

成员

成员 默认值
public static const flag_type icase regex_constants::icase
public static const flag_type nosubs regex_constants::nosubs
public static const flag_type optimize regex_constants::optimize
public static const flag_type collate regex_constants::collate
public static const flag_type ECMAScript regex_constants::ECMAScript
public static const flag_type basic regex_constants::basic
public static const flag_type extended regex_constants::extended
public static const flag_type awk regex_constants::awk
public static const flag_type grep regex_constants::grep
public static const flag_type egrep regex_constants::egrep
private RXtraits traits

构造函数

构造函数 说明
basic_regex 构造正则表达式对象。

Typedef

类型名称 说明
flag_type 语法选项标志的类型。
locale_type 存储的区域设置对象的类型。
value_type 元素类型。

成员函数

成员函数 说明
assign 将一个值分配到正则表达式对象。
flags 返回语法选项标志。
getloc 返回存储的区域设置对象。
imbue 更改存储的区域设置对象。
mark_count 返回匹配的子表达式的数目。
swap 交换两个正则表达式对象。

运算符

运算符 说明
operator= 将一个值分配到正则表达式对象。

要求

标头：<regex>

命名空间： std

示例

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

using namespace std;

int main()
{
    regex::value_type elem = 'x';
    regex::flag_type flag = regex::grep;

    elem = elem;  // to quiet "unused" warnings
    flag = flag;

    // constructors
    regex rx0;
    cout << "match(\"abc\", \"\") == " << boolalpha
        << regex_match("abc", rx0) << endl;

    regex rx1("abcd", regex::ECMAScript);
    cout << "match(\"abc\", \"abcd\") == " << boolalpha
        << regex_match("abc", rx1) << endl;

    regex rx2("abcd", 3);
    cout << "match(\"abc\", \"abc\") == " << boolalpha
        << regex_match("abc", rx2) << endl;

    regex rx3(rx2);
    cout << "match(\"abc\", \"abc\") == " << boolalpha
        << regex_match("abc", rx3) << endl;

    string str("abcd");
    regex rx4(str);
    cout << "match(string(\"abcd\"), \"abc\") == " << boolalpha
        << regex_match("abc", rx4) << endl;

    regex rx5(str.begin(), str.end() - 1);
    cout << "match(string(\"abc\"), \"abc\") == " << boolalpha
        << regex_match("abc", rx5) << endl;
    cout << endl;

    // assignments
    rx0 = "abc";
    rx0 = rx1;
    rx0 = str;

    rx0.assign("abcd", regex::ECMAScript);
    rx0.assign("abcd", 3);
    rx0.assign(rx1);
    rx0.assign(str);
    rx0.assign(str.begin(), str.end() - 1);

    rx0.swap(rx1);

    // mark_count
    cout << "\"abc\" mark_count == "
        << regex("abc").mark_count() << endl;
    cout << "\"(abc)\" mark_count == "
        << regex("(abc)").mark_count() << endl;

    // locales
    regex::locale_type loc = rx0.imbue(locale());
    cout << "getloc == imbued == " << boolalpha
        << (loc == rx0.getloc()) << endl;

    // initializer_list
    regex rx6({ 'a', 'b', 'c' }, regex::ECMAScript);
    cout << "match(\"abc\") == " << boolalpha
        << regex_match("abc", rx6);
    cout << endl;
}

match("abc", "") == false
match("abc", "abcd") == false
match("abc", "abc") == true
match("abc", "abc") == true
match(string("abcd"), "abc") == false
match(string("abc"), "abc") == true

"abc" mark_count == 0
"(abc)" mark_count == 1
getloc == imbued == true
match("abc") == true

basic_regex::assign

将一个值分配到正则表达式对象。

basic_regex& assign(
    const basic_regex& right);

basic_regex& assign(
    const Elem* ptr,
    flag_type flags = ECMAScript);

basic_regex& assign(
    const Elem* ptr,
    size_type len,
    flag_type flags = ECMAScript);

basic_regex& assign(
    initializer_list<_Elem> IList,
    flag_type flags = regex_constants::ECMAScript);

template <class STtraits, class STalloc>
basic_regex& assign(
    const basic_string<Elem, STtraits, STalloc>& str,
    flag_type flags = ECMAScript);

template <class InIt>
basic_regex& assign(
    InIt first, InIt last,
    flag_type flags = ECMAScript);

参数

STtraits
字符串源的特征类。

STalloc
字符串源的分配器类。

InIt
范围源的输入迭代器类型。

right
要复制的正则表达式源。

ptr
指向要复制的序列开头的指针。

flags
复制时要添加的语法选项标志。

len/TD>
要复制的序列的长度。

str
要复制的字符串。

first
要复制的序列的开头。

last
要复制的序列的结尾。

IList
要复制的 initializer_list。

注解

每个成员函数将 *this 保留的正则表达式替换为操作数序列所描述的正则表达式，然后返回 *this。

basic_regex::basic_regex

构造正则表达式对象。

basic_regex();

explicit basic_regex(
    const Elem* ptr,
    flag_type flags);

explicit basic_regex(
    const Elem* ptr,
    size_type len,
    flag_type flags);

basic_regex(
    const basic_regex& right);

basic_regex(
    initializer_list<Type> IList,
    flag_type flags);

template <class STtraits, class STalloc>
explicit basic_regex(
    const basic_string<Elem, STtraits, STalloc>& str,
    flag_type flags);

template <class InIt>
explicit basic_regex(
    InIt first,
    InIt last,
    flag_type flags);

参数

STtraits
字符串源的特征类。

STalloc
字符串源的分配器类。

InIt
范围源的输入迭代器类型。

right
要复制的正则表达式源。

ptr
指向要复制的序列开头的指针。

flags
复制时要添加的语法选项标志。

len/TD>
要复制的序列的长度。

str
要复制的字符串。

first
要复制的序列的开头。

last
要复制的序列的结尾。

IList
要复制的 initializer_list。

备注

所有构造函数将存储类型 RXtraits 的默认构造对象。

第一个构造函数构造一个空 basic_regex 对象。 其他构造函数构造 basic_regex 对象，其中包含由操作数序列描述的正则表达式。

一个空 basic_regex 对象在被传递给 regex_match、regex_search 或 regex_replace 时不匹配任何字符序列。

basic_regex::flag_type

语法选项标志的类型。

typedef regex_constants::syntax_option_type flag_type;

注解

该类型是 regex_constants::syntax_option_type 的同义词。

basic_regex::flags

返回语法选项标志。

flag_type flags() const;

备注

成员函数返回 flag_type 自变量的值，该值传递到对一个 basic_regex::assign 成员函数的最近调用，或者如果没有实施这类调用，则返回传递到构造函数的值。

basic_regex::getloc

返回存储的区域设置对象。

locale_type getloc() const;

注解

成员函数将返回 traits.regex_traits::getloc()。

basic_regex::imbue

更改存储的区域设置对象。

locale_type imbue(locale_type loc);

参数

loc
要存储的区域设置对象。

注解

该成员函数将清空 *this 并返回 traits.regex_traits::imbue(loc)。

basic_regex::locale_type

存储的区域设置对象的类型。

typedef typename RXtraits::locale_type locale_type;

注解

该类型是 regex_traits::locale_type的同义词。

basic_regex::mark_count

返回匹配的子表达式的数目。

unsigned mark_count() const;

备注

成员函数将返回正则表达式中的捕获组数量。

basic_regex::operator=

将一个值分配到正则表达式对象。

basic_regex& operator=(const basic_regex& right);

basic_regex& operator=(const Elem *str);

template <class STtraits, class STalloc>
basic_regex& operator=(const basic_string<Elem, STtraits, STalloc>& str);

参数

STtraits
字符串源的特征类。

STalloc
字符串源的分配器类。

right
要复制的正则表达式源。

str
要复制的字符串。

备注

每个运算符将 *this 保留的正则表达式替换为操作数序列所描述的正则表达式，然后返回 *this。

basic_regex::swap

交换两个正则表达式对象。

void swap(basic_regex& right) throw();

参数

right
要交换的正则表达式对象。

备注

成员函数交换 *this 和 right 之间的正则表达式。 它定时执行此操作且不引发异常。

basic_regex::value_type

元素类型。

typedef Elem value_type;

注解

该类型是模板参数 Elem 的同义词。

另请参阅

<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits 类