basic_regex 類別

包裝規則運算式。

語法

template <class Elem, class RXtraits>
class basic_regex

參數

Elem
要符合之項目的類型。

RXtraits
項目的 Traits 類別。

備註

類別範本描述保留正則表達式的物件。 這個類別範本的物件可以傳遞至範本函 式regex_match、 regex_search和 regex_replace。 它也會傳遞適當的文字字串自變數，以搜尋符合正則表達式的文字。 此類別範本有兩個特製化，類型定義的 regex 適用於類型char的專案，以及類型 wchar_t專案的 wregex。

範本自變數 RXtraits 描述類別範本所支援之正則表示式語法的各種重要屬性。 指定這些正則表達式特性的類別，必須與類型regex_traits Class 的物件具有相同的外部介面。

有些函式會接受定義規則運算式的運算元序列。 您可以透過數種方法指定這類運算元序列：

ptr：以 Null 結束的序列 （例如 C 字串，適用於類型的 Elem），開頭ptr為 （這不得為 Null 指標），其中終止專案是值value_type()，且不屬於操作數char序列的一部分

ptr，count：從 開始ptr的count元素序列（不得為 Null 指標）

str：物件指定的 basic_string 序列 str

first， last：範圍中由反覆運算器和 first last分隔的元素序列 [first, last)

rightbasic_regex：物件right

除了 RXtraits 類型所描述的選項之外，上述成員函式也會採用自變數flags，指定正則表示式解譯的各種選項。

成員

member	預設值
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
私用 RX 特性特性

建構函式

建構函式	描述
basic_regex	建構規則運算式物件

Typedefs

類型名稱	描述
flag_type	語法選項旗標類型。
locale_type	儲存的地區設定物件類型。
value_type	元素類型。

成員函式

成員函數	描述
assign	將值指派給規則運算式物件。
flags	傳回語法選項旗標。
getloc	傳回儲存的地區設定物件。
imbue	修改儲存的地區設定物件。
mark_count	傳回符合的子運算式數目。
swap	交換兩個規則運算式物件。

操作員

運算子	描述
operator=	將值指派給規則運算式物件。

需求

Header：<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
字串來源的 Traits 類別。

STalloc
字串來源的 Allocator 類別。

InIt
輸入範圍來源的迭代器類型。

right
要複製的 Regex 來源。

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
字串來源的 Traits 類別。

STalloc
字串來源的 Allocator 類別。

InIt
輸入範圍來源的迭代器類型。

right
要複製的 Regex 來源。

ptr
要複製之序列開頭的指標。

flags
要在複製時加入的語法選項旗標。

len/TD>
要複製之序列的長度。

str
要複製的字串。

first
要複製之序列的開頭。

last
要複製之序列的結尾。

IList
要複製的 initializer_list。

備註

所有的建構函式都會儲存 RXtraits 類型的預設建構物件。

第一個建構函式會建構空的 basic_regex 物件。 其他建構函式會建構 basic_regex 物件，其保存運算元序列所描述的規則運算式。

當傳遞至regex_match、regex_search或regex_replace時，空basic_regex的物件不符合任何字元序列。

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
字串來源的 Traits 類別。

STalloc
字串來源的 Allocator 類別。

right
要複製的 Regex 來源。

str
要複製的字串。

備註

這些運算子會分別將 *this 所含的規則運算式取代為運算元序列所描述的規則運算式，然後傳回 *this。

basic_regex：：swap

交換兩個規則運算式物件。

void swap(basic_regex& right) throw();

參數

right
要交換的規則運算式物件。

備註

成員函式會在和 右側之間*this交換正則表達式。 它會在固定時間執行但不會擲回任何例外狀況。

basic_regex：：value_type

元素類型。

typedef Elem value_type;

備註

此類型與範本參數 Elem 同義。

另請參閱

<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits 類別