basic_regex – třída
Zabalí regulární výraz.
template <class Elem, class RXtraits>
class basic_regex
Elem
Typ prvků, které se mají spárovat.
RXtraits
Třída vlastností prvků.
Š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 .
| Č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 |
| Konstruktor | Popis |
|---|---|
| basic_regex | Vytvořte objekt regulárního výrazu. |
| 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. |
| Č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átor | Popis |
|---|---|
| operator= | Přiřadí hodnotu objektu regulárního výrazu. |
Header:<regex>
Obor názvů: 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
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);
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í.
Č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.
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);
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í.
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.
Typ příznaku možnosti syntaxe.
typedef regex_constants::syntax_option_type flag_type;
Typ je synonymem pro regex_constants::syntax_option_type.
Vrátí příznaky možností syntaxe.
flag_type flags() const;
Č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.
Vrátí uložený objekt národního prostředí.
locale_type getloc() const;
Členová funkce vrátí traits.regex_traits::getloc().
Změní uložený objekt národního prostředí.
locale_type imbue(locale_type loc);
Loc
Objekt národního prostředí, který se má uložit.
Členová funkce vyprázdní *this a vrátítraits. regex_traits::imbue(loc).
Typ uloženého objektu národního prostředí.
typedef typename RXtraits::locale_type locale_type;
Typ je synonymem pro regex_traits::locale_type.
Vrátí počet odpovídajících dílčích výrazů.
unsigned mark_count() const;
Členová funkce vrátí počet skupin zachycení v regulárním výrazu.
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);
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.
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.
Prohodí dva objekty regulárního výrazu.
void swap(basic_regex& right) throw();
Vpravo
Objekt regulárního výrazu, se kterým se má prohodit.
Členová funkce prohodí regulární výrazy mezi *this a vpravo. Provede to v konstantním čase a nevyvolá žádné výjimky.
Typ elementu.
typedef Elem value_type;
Typ je synonymem pro parametr šablony Elem.
<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits – třída