basic_regex — Klasa

Owija wyrażenie regularne.

Składnia

template <class Elem, class RXtraits>
class basic_regex

Parametry

Elem
Typ elementów, do których ma pasować.

RXtraits
Klasa cech dla elementów.

Uwagi

Szablon klasy opisuje obiekt, który zawiera wyrażenie regularne. Obiekty tego szablonu klasy można przekazać do funkcji szablonu regex_match, regex_search i regex_replace. Przekazuje również odpowiednie argumenty ciągu tekstowego, aby wyszukać tekst zgodny z wyrażeniem regularnym. Istnieją dwie specjalizacje tego szablonu klasy, z definicjami typów wyrażeń regularnych dla elementów typu chari wregex dla elementów typu wchar_t.

Argument szablonu RXtraits opisuje różne ważne właściwości składni wyrażeń regularnych, które obsługuje szablon klasy. Klasa określająca te cechy wyrażeń regularnych musi mieć ten sam interfejs zewnętrzny co obiekt typu regex_traits Klasa.

Niektóre funkcje przyjmują sekwencję operandów, która definiuje wyrażenie regularne. Można określić taką sekwencję operandów na kilka sposobów:

ptr: sekwencja zakończona o wartości null (na przykład ciąg C, dla elem typu char) rozpoczynająca się od ptr (która nie może być wskaźnikiem o wartości null), gdzie element zakończenia jest wartością value_type() i nie jest częścią sekwencji operandu

ptr, count: sekwencja elementów rozpoczynających count się od ptr (które nie mogą być wskaźnikiem o wartości null)

str: sekwencja określona basic_string przez obiekt str

first, last: sekwencja elementów rozdzielonych przez iteratory first i last, w zakresie [first, last)

rightbasic_regex: obiektright

Powyższe funkcje składowe przyjmują również argument flags określający różne opcje interpretacji wyrażenia regularnego oprócz opcji opisanych przez typ RXtraits .

Elementy członkowskie

Element członkowski	Wartość domyślna
publiczny statyczny const flag_type icase	regex_constants::icase
publiczny statyczny const flag_type nosubs	regex_constants::nosubs
publiczna statyczna flag_type optymalizowanie	regex_constants::optimize
publiczne połączenie statyczne flag_type	regex_constants::collate
publiczny statyczny flag_type ECMAScript	regex_constants::ECMAScript
publiczny statyczny const flag_type basic	regex_constants::basic
publiczne statyczne flag_type rozszerzone	regex_constants::extended
publiczny statyczny const flag_type awk	regex_constants::awk
publiczny statyczny const flag_type grep	regex_constants::grep
publiczny statyczny const flag_type egrep	regex_constants::egrep
prywatne cechy RXtraits

Konstruktory

Konstruktor	opis
basic_regex	Skonstruuj obiekt wyrażenia regularnego.

Typedefs

Nazwa typu	opis
flag_type	Typ flag opcji składni.
locale_type	Typ przechowywanego obiektu ustawień regionalnych.
value_type	Typ elementu.

Funkcje składowe

Funkcja składowa	opis
przypisać	Przypisuje wartość do obiektu wyrażenia regularnego.
Flagi	Zwraca flagi opcji składni.
getloc	Zwraca przechowywany obiekt ustawień regionalnych.
Nasycić	Zmienia przechowywany obiekt ustawień regionalnych.
mark_count	Zwraca liczbę dopasowanych podwyrażeń.
zamiana	Zamienia dwa obiekty wyrażeń regularnych.

Operatory

Operator	opis
operator =	Przypisuje wartość do obiektu wyrażenia regularnego.

Wymagania

Nagłówek:<regex>

Przestrzeń nazw: std

Przykład

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

Przypisuje wartość do obiektu wyrażenia regularnego.

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
Klasa Traits dla źródła ciągów.

STalloc
Klasa alokatora dla źródła ciągów.

Init
Typ iteratora wejściowego dla źródła zakresu.

Prawy
Źródło wyrażeń regularnych do skopiowania.

ptr
Wskaźnik na początek sekwencji do skopiowania.

Flagi
Flagi opcji składni do dodania podczas kopiowania.

len/TD>
Długość sekwencji do skopiowania.

Str
Ciąg do skopiowania.

pierwszy
Początek sekwencji do skopiowania.

ostatni
Koniec sekwencji do skopiowania.

IList
Initializer_list do skopiowania.

Uwagi

Funkcje składowe zastępują wyrażenie regularne przechowywane za *this pomocą wyrażenia regularnego opisanego przez sekwencję operandu, a następnie zwracają wartość *this.

basic_regex::basic_regex

Skonstruuj obiekt wyrażenia regularnego.

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
Klasa Traits dla źródła ciągów.

STalloc
Klasa alokatora dla źródła ciągów.

Init
Typ iteratora wejściowego dla źródła zakresu.

Prawy
Źródło wyrażeń regularnych do skopiowania.

ptr
Wskaźnik na początek sekwencji do skopiowania.

Flagi
Flagi opcji składni do dodania podczas kopiowania.

len/TD>
Długość sekwencji do skopiowania.

Str
Ciąg do skopiowania.

pierwszy
Początek sekwencji do skopiowania.

ostatni
Koniec sekwencji do skopiowania.

IList
Initializer_list do skopiowania.

Uwagi

Wszystkie konstruktory przechowują domyślny obiekt typu RXtraits.

Pierwszy konstruktor tworzy pusty basic_regex obiekt. Inne konstruktory skonstruuje basic_regex obiekt, który zawiera wyrażenie regularne opisane przez sekwencję operandów.

basic_regex Pusty obiekt nie jest zgodny z żadną sekwencją znaków po przekazaniu do regex_match, regex_search lub regex_replace.

basic_regex::flag_type

Typ flag opcji składni.

typedef regex_constants::syntax_option_type flag_type;

Uwagi

Typ jest synonimem regex_constants ::syntax_option_type.

basic_regex::flags

Zwraca flagi opcji składni.

flag_type flags() const;

Uwagi

Funkcja składowa zwraca wartość argumentu flag_type przekazanego do ostatniego wywołania do jednego z funkcji basic_regex::assign member lub, jeśli takie wywołanie nie zostało wykonane, wartość przekazana do konstruktora.

basic_regex::getloc

Zwraca przechowywany obiekt ustawień regionalnych.

locale_type getloc() const;

Uwagi

Funkcja składowa zwraca traits.regex_traits::getloc().

basic_regex::imbue

Zmienia przechowywany obiekt ustawień regionalnych.

locale_type imbue(locale_type loc);

Parametry

Loc
Obiekt ustawień regionalnych do przechowywania.

Uwagi

Funkcja składowa opróżnia *this i zwraca traits.regex_traits::imbue(loc).

basic_regex::locale_type

Typ przechowywanego obiektu ustawień regionalnych.

typedef typename RXtraits::locale_type locale_type;

Uwagi

Typ jest synonimem regex_traits ::locale_type.

basic_regex::mark_count

Zwraca liczbę dopasowanych podwyrażeń.

unsigned mark_count() const;

Uwagi

Funkcja składowa zwraca liczbę grup przechwytywania w wyrażeniu regularnym.

basic_regex::operator=

Przypisuje wartość do obiektu wyrażenia regularnego.

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
Klasa Traits dla źródła ciągów.

STalloc
Klasa alokatora dla źródła ciągów.

Prawy
Źródło wyrażeń regularnych do skopiowania.

Str
Ciąg do skopiowania.

Uwagi

Operatory, z których każda zastępuje wyrażenie regularne przechowywane *this za pomocą wyrażenia regularnego opisanego przez sekwencję operandu, a następnie zwracają wartość *this.

basic_regex::swap

Zamienia dwa obiekty wyrażeń regularnych.

void swap(basic_regex& right) throw();

Parametry

Prawy
Obiekt wyrażenia regularnego do zamiany.

Uwagi

Funkcja składowa zamienia wyrażenia regularne między *this i po prawej. Robi to w stałym czasie i nie zgłasza żadnych wyjątków.

basic_regex::value_type

Typ elementu.

typedef Elem value_type;

Uwagi

Typ jest synonimem parametru szablonu Elem.

Zobacz też

<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits, klasa