std::basic_regex<CharT,Traits>::basic_regex

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

技术规范

符号索引

外部库

 

正则表达式库

类

basic_regex (C++11)

sub_match (C++11)

match_results (C++11)

算法

regex_match (C++11)

regex_search (C++11)

regex_replace (C++11)

迭代器

regex_iterator (C++11)

regex_token_iterator (C++11)

异常

regex_error (C++11)

特征

regex_traits (C++11)

常量

syntax_option_type (C++11)

match_flag_type (C++11)

error_type (C++11)

正则表达式文法

有改动的 ECMAScript-262 文法 (C++11)

 

std::basic_regex

成员函数

basic_regex::basic_regex

basic_regex::~basic_regex

basic_regex::operator=

basic_regex::assign

观察器

basic_regex::mark_count

basic_regex::flags

本地环境

basic_regex::getloc

basic_regex::imbue

修改器

basic_regex::swap

常量

非成员函数

swap(std::basic_regex)

推导指引(C++17)

 

basic_regex();	(1)	(C++11 起)
explicit basic_regex( const CharT* s,                       flag_type f = std::regex_constants::ECMAScript );	(2)	(C++11 起)
basic_regex( const CharT* s, std::size_t count,              flag_type f = std::regex_constants::ECMAScript );	(3)	(C++11 起)
basic_regex( const basic_regex& other );	(4)	(C++11 起)
basic_regex( basic_regex&& other ) noexcept;	(5)	(C++11 起)
template< class ST, class SA > explicit basic_regex( const std::basic_string<CharT,ST,SA>& str,                       flag_type f = std::regex_constants::ECMAScript );	(6)	(C++11 起)
template< class ForwardIt > basic_regex( ForwardIt first, ForwardIt last,              flag_type f = std::regex_constants::ECMAScript );	(7)	(C++11 起)
basic_regex( std::initializer_list<CharT> init,              flag_type f = std::regex_constants::ECMAScript );	(8)	(C++11 起)

从按照标志 f 进行解释的字符序列构造新的正则表达式。

1) 默认构造函数。构造不匹配任何内容的空正则表达式。

2) 从空终止字符串 s 构造正则表达式。

3) 从 s 所指向的 count 个的字符序列构造正则表达式。

4) 复制构造函数。通过复制 other 构造正则表达式。

5) 移动构造函数。用移动语义构造拥有 other 内容的正则表达式。

6) 从字符串 str 构造正则表达式。

7) 范围构造函数。构造拥有范围 [first, last) 内容的正则表达式。

8) 初始化式列表构造函数。构造拥有初始化式列表 init 内容的正则表达式。

参数

s	-	指向空终止字符串的指针
count	-	用于初始化正则表达式的字符序列长度
first, last	-	用于初始化正则表达式的字符序列范围
str	-	用作源初始化正则表达式的 basic_string
other	-	用作源初始化正则表达式的另一正则表达式
init	-	用于初始化正则表达式的初始化式列表
f	-	用于指引转译字符序列为正则表达式的标志
类型要求
- ForwardIt 必须满足老式向前迭代器 (LegacyForwardIterator) 。

异常

1) 可能会抛出由实现定义的异常。

2,3) 若提供的正则表达式非法则为 std::regex_error。

4) 可能会抛出由实现定义的异常。

6-8) 若提供的正则表达式非法则为 std::regex_error。

示例

运行此代码

#include <iomanip>
#include <iostream>
#include <regex>
#include <string>
 
void match_and_print(const std::string& text, const std::regex& pattern)
{
    std::sregex_iterator it(text.begin(), text.end(), pattern), it_end;
    int count = 0;
    for (; it != it_end; ++it)
    {
        const std::smatch& match = *it;
        std::cout << ++count << ". " << std::quoted(match.str()) << '\n';
    }
    std::cout << (count ? "\n" : "未找到匹配\n\n");
}
 
int main()
{
    const std::string text = "Hello, World! 12345";
 
    // 匹配一个或更多数字
    std::string pattern_text = "\\d+";
    std::cout << "数字 (" << pattern_text << "):\n";
    auto pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
 
    // 匹配按空白分隔的一个或更多字符
    pattern_text = "[^\\s]+";
    std::cout << "单词 (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
 
    // 匹配按空白分隔的一个或更多字符
    pattern_text = "[a-zA-Z]+";
    std::cout << "不带符号和数字的单词 (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
 
    // 匹配一个非数字、非字母字符
    pattern_text = "[^0-9A-Za-z]";
    std::cout << "符号 (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
 
    // 匹配一个或多个小写字母
    pattern_text = "[a-z]+";
    std::cout << "小写 (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
 
    // 匹配一个或多个小写字母，带有 std::regex::icase 标志
    pattern_text = "[a-z]+";
    std::cout << "小写并带有忽略大小写标志 (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::icase);
    match_and_print(text, pattern);
 
    // 匹配基本 POSIX 正则表达式 
    pattern_text = "[[:digit:]]+";
    std::cout << "基本 POSIX 正则表达式 (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::basic);
    match_and_print(text, pattern);
 
    // 匹配扩展 POSIX 正则表达式
    pattern_text = "[[:digit:]]+";
    std::cout << "扩展 POSIX 正则表达式 (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::extended);
    match_and_print(text, pattern);
}

输出：

数字 (\d+):
1. "12345"
 
单词 ([^\s]+):
1. "Hello,"
2. "World!"
3. "12345"
 
不带符号和数字的单词 ([a-zA-Z]+):
1. "Hello"
2. "World"
 
符号 ([^0-9A-Za-z]):
1. ","
2. " "
3. "!"
4. " "
 
小写 ([a-z]+):
1. "ello"
2. "orld"
 
小写并带有忽略大小写标志 ([a-z]+):
1. "Hello"
2. "World"
 
基本 POSIX 正则表达式 ([[:digit:]]+):
未找到匹配
 
扩展 POSIX 正则表达式 ([[:digit:]]+):
1. "12345"