basic_regex – třída

Zabalí regulární výraz.

Syntaxe

template <class Elem, class RXtraits>
class basic_regex

Parametry

Elem
Typ prvků, které se mají spárovat.

RXtraits
Třída vlastností prvků.

Poznámky

Šablona třídy popisuje objekt, který obsahuje regulární výraz. Objekty této šablony třídy lze předat funkcím šablony regex_match, regex_search a regex_replace. Předá také vhodné argumenty textového řetězce, aby vyhledaly text, který odpovídá regulárnímu výrazu. Existují dvě specializace této šablony třídy, s definicemi typů regex pro prvky typu chara wregex pro prvky typu wchar_t.

Argument šablony RXtraits popisuje různé důležité vlastnosti syntaxe regulárních výrazů, které šablona třídy podporuje. Třída, která určuje tyto vlastnosti regulárních výrazů musí mít stejné externí rozhraní jako objekt typu regex_traits Třída.

Některé funkce provádějí sekvenci operandu, která definuje regulární výraz. Tuto sekvenci operandů můžete zadat několika způsoby:

ptr: Sekvence ukončená hodnotou null (například řetězec C, pro Elem typu char) začínající ptr (nesmí být ukazatelem null), kde ukončovací prvek je hodnota value_type() a není součástí sekvence operandu.

ptr, count: posloupnost count prvků začínajících ( ptr která nesmí být ukazatelem null)

str: posloupnost určená objektem basic_stringstr

first, last: posloupnost prvků oddělených iterátory first a lastv rozsahu [first, last)

rightbasic_regex: objektright

Výše uvedené členské funkce také berou argument flags , který určuje různé možnosti interpretace regulárního výrazu kromě možností popsaných typem RXtraits .

Členové

Člen	Výchozí hodnota
public static const flag_type icase	regex_constants::icase
veřejná statická const flag_type nosubs	regex_constants::nosubs
optimalizace veřejných statických flag_type	regex_constants::optimize
veřejná statická flag_type kolace	regex_constants::collate
veřejná statická 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
veřejná statická const flag_type egrep	regex_constants::egrep
private RXtraits traits

Konstruktory

Konstruktor	Popis
basic_regex	Vytvořte objekt regulárního výrazu.

Typedefs

Název typu	Popis
flag_type	Typ příznaku možnosti syntaxe.
locale_type	Typ uloženého objektu národního prostředí.
value_type	Typ elementu.

Členské funkce

Členová funkce	Popis
přiřadit	Přiřadí hodnotu objektu regulárního výrazu.
vlajky	Vrátí příznaky možností syntaxe.
getloc	Vrátí uložený objekt národního prostředí.
naplnit	Změní uložený objekt národního prostředí.
mark_count	Vrátí počet odpovídajících dílčích výrazů.
vyměnit	Prohodí dva objekty regulárního výrazu.

Operátory

Operátor	Popis
operator=	Přiřadí hodnotu objektu regulárního výrazu.

Požadavky

Header:<regex>

Obor názvů: std

Příklad

// 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

Přiřadí hodnotu objektu regulárního výrazu.

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);

Parametry

STtraits
Traits – třída pro zdroj řetězců

STalloc
Allocator – třída pro zdroj řetězců.

Init
Typ vstupního iterátoru pro zdroj rozsahu

Vpravo
Zdroj regulárních výrazů pro kopírování.

ptr
Ukazatel na začátek sekvence, která se má kopírovat.

vlajky
Příznaky možností syntaxe, které se mají přidat při kopírování.

délka/TD>
Délka sekvence, kterou chcete zkopírovat.

Str
Řetězec, který chcete zkopírovat.

první
Začátek sekvence ke kopírování

poslední
Konec sekvence, která se má zkopírovat

IList
Initializer_list ke zkopírování.

Poznámky

Členské funkce každý nahradí regulární výraz uchovávaný regulárním výrazem *this popsaným pořadím operandu a pak vrátí *this.

basic_regex::basic_regex

Vytvořte objekt regulárního výrazu.

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);

Parametry

STtraits
Traits – třída pro zdroj řetězců

STalloc
Allocator – třída pro zdroj řetězců.

Init
Typ vstupního iterátoru pro zdroj rozsahu

Vpravo
Zdroj regulárních výrazů pro kopírování.

ptr
Ukazatel na začátek sekvence, která se má kopírovat.

vlajky
Příznaky možností syntaxe, které se mají přidat při kopírování.

délka/TD>
Délka sekvence, kterou chcete zkopírovat.

Str
Řetězec, který chcete zkopírovat.

první
Začátek sekvence ke kopírování

poslední
Konec sekvence, která se má zkopírovat

IList
Initializer_list ke zkopírování.

Poznámky

Všechny konstruktory ukládají výchozí vytvořený objekt typu RXtraits.

První konstruktor vytvoří prázdný basic_regex objekt. Ostatní konstruktory vytvoří basic_regex objekt, který obsahuje regulární výraz popsaný v posloupnosti operandu.

Prázdný basic_regex objekt neodpovídá žádné sekvenci znaků při předání do regex_match, regex_search nebo regex_replace.

basic_regex::flag_type

Typ příznaku možnosti syntaxe.

typedef regex_constants::syntax_option_type flag_type;

Poznámky

Typ je synonymem pro regex_constants::syntax_option_type.

basic_regex::flags

Vrátí příznaky možností syntaxe.

flag_type flags() const;

Poznámky

Členová funkce vrátí hodnotu argumentu flag_type předaného poslednímu volání některého z basic_regex::assign členské funkce, nebo pokud nebylo provedeno žádné takové volání, předaná hodnota konstruktoru.

basic_regex::getloc

Vrátí uložený objekt národního prostředí.

locale_type getloc() const;

Poznámky

Členová funkce vrátí traits.regex_traits::getloc().

basic_regex::imbue

Změní uložený objekt národního prostředí.

locale_type imbue(locale_type loc);

Parametry

Loc
Objekt národního prostředí, který se má uložit.

Poznámky

Členová funkce vyprázdní *this a vrátítraits. regex_traits::imbue(loc).

basic_regex::locale_type

Typ uloženého objektu národního prostředí.

typedef typename RXtraits::locale_type locale_type;

Poznámky

Typ je synonymem pro regex_traits::locale_type.

basic_regex::mark_count

Vrátí počet odpovídajících dílčích výrazů.

unsigned mark_count() const;

Poznámky

Členová funkce vrátí počet skupin zachycení v regulárním výrazu.

basic_regex::operator=

Přiřadí hodnotu objektu regulárního výrazu.

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);

Parametry

STtraits
Traits – třída pro zdroj řetězců

STalloc
Allocator – třída pro zdroj řetězců.

Vpravo
Zdroj regulárních výrazů pro kopírování.

Str
Řetězec, který chcete zkopírovat.

Poznámky

Operátory každý nahradí regulární výraz uchovávaný regulárním výrazem *this popsaným pořadím operandu a pak vrátí *this.

basic_regex::swap

Prohodí dva objekty regulárního výrazu.

void swap(basic_regex& right) throw();

Parametry

Vpravo
Objekt regulárního výrazu, se kterým se má prohodit.

Poznámky

Členová funkce prohodí regulární výrazy mezi *this a vpravo. Provede to v konstantním čase a nevyvolá žádné výjimky.

basic_regex::value_type

Typ elementu.

typedef Elem value_type;

Poznámky

Typ je synonymem pro parametr šablony Elem.

Viz také

<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits – třída