`<regex>`, funkcje

Artykuł
10/12/2023

Nazwa/nazwisko	opis
`regex_match`	Sprawdza, czy wyrażenie regularne pasuje do całego ciągu docelowego.
`regex_replace`	Zamienia dopasowane wyrażenia regularne.
`regex_search`	Wyszukuje dopasowanie wyrażenia regularnego.
`swap`	Zamienia dwa `basic_regex` obiekty lub `match_results` .

`regex_match`

Sprawdza, czy wyrażenie regularne pasuje do całego ciągu docelowego.

// (1)
template <class BidIt, class Alloc, class Elem, class RXtraits, class Alloc2>
bool regex_match(
    BidIt first,
    Bidit last,
    match_results<BidIt, Alloc>& match,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

// (2)
template <class BidIt, class Elem, class RXtraits, class Alloc2>
bool regex_match(
    BidIt first,
    Bidit last,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

// (3)
template <class Elem, class Alloc, class RXtraits, class Alloc2>
bool regex_match(
    const Elem *ptr,
    match_results<const Elem*, Alloc>& match,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

// (4)
template <class Elem, class RXtraits, class Alloc2>
bool regex_match(
    const Elem *ptr,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

// (5)
template <class IOtraits, class IOalloc, class Alloc, class Elem, class RXtraits, class Alloc2>
bool regex_match(
    const basic_string<Elem, IOtraits, IOalloc>& str,
    match_results<typename basic_string<Elem, IOtraits, IOalloc>::const_iterator, Alloc>& match,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

// (6)
template <class IOtraits, class IOalloc, class Elem, class RXtraits, class Alloc2>
bool regex_match(
    const basic_string<Elem, IOtraits, IOalloc>& str,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

Parametry

BidIt
Typ iteratora dla podmatów. W przypadku typowych przypadków ten jeden z string::const_iterator, wstring::const_iteratorconst char* lub const wchar_t*.

Alloc
Klasa alokatora wyników dopasowania.

Elem
Typ elementów, do których ma pasować. W typowych przypadkach jest stringto , char* wstringlub wchar_t*.

RXtraits
Klasa cech dla elementów.

Alloc2
Klasa alokatora wyrażeń regularnych.

IOtraits
Klasa cech ciągów.

IOalloc
Klasa alokatora ciągów.

flags
Flagi dopasowań.

first
Początek sekwencji do dopasowania.

last
Koniec sekwencji, która ma być zgodna.

match
Wyniki dopasowania. Odpowiada typowi Elem: smatch dla string, dla , wsmatch dla char* wstringlub wcmatch cmatch dla wchar_t*.

ptr
Wskaźnik na początek sekwencji do dopasowania. Jeśli ptr ma wartość char*, użyj polecenia cmatch i regex. Jeśli ptr to polecenie , wchar_t* użyj polecenia wcmatch i wregex.

re
Wyrażenie regularne do dopasowania. Typ regex dla string i , lub wregex dla wstring i wchar_t*char*.

str
Ciąg do dopasowania. Odpowiada typowi Elem.

Uwagi

Każda funkcja szablonu zwraca wartość true tylko wtedy, gdy cała sekwencja str operandu dokładnie pasuje do argumentu rewyrażenia regularnego . Służy regex_search do dopasowywania podciągów w sekwencji docelowej i regex_iterator znajdowania wielu dopasowań. Funkcje, które przyjmują match_results obiekt, ustawiają jego elementy członkowskie, aby odzwierciedlić, czy dopasowanie zakończyło się pomyślnie, a jeśli tak, jakie są przechwycone różne grupy przechwytywania w wyrażeniu regularnym.

Funkcje, które przyjmują match_results obiekt, ustawiają jego elementy członkowskie, aby odzwierciedlić, czy dopasowanie zakończyło się pomyślnie, a jeśli tak, jakie są przechwycone różne grupy przechwytywania w wyrażeniu regularnym.

Przykład

// std__regex__regex_match.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>

using namespace std;

int main()
{
    // (1) with char*
    // Note how const char* requires cmatch and regex
    const char *first = "abc";
    const char *last = first + strlen(first);
    cmatch narrowMatch;
    regex rx("a(b)c");

    bool found = regex_match(first, last, narrowMatch, rx);
    if (found)
        wcout << L"Regex found in abc" << endl;

    // (2) with std::wstring
    // Note how wstring requires wsmatch and wregex.
    // Note use of const iterators cbegin() and cend().
    wstring target(L"Hello");
    wsmatch wideMatch;
    wregex wrx(L"He(l+)o");

    if (regex_match(target.cbegin(), target.cend(), wideMatch, wrx))
        wcout << L"The matching text is:" << wideMatch.str() << endl;

    // (3) with std::string
    string target2("Drizzle");
    regex rx2(R"(D\w+e)"); // no double backslashes with raw string literal

    found = regex_match(target2.cbegin(), target2.cend(), rx2);
    if (found)
        wcout << L"Regex found in Drizzle" << endl;

    // (4) with wchar_t*
    const wchar_t* target3 = L"2014-04-02";
    wcmatch wideMatch2;

    // LR"(...)" is a  raw wide-string literal. Open and close parens
    // are delimiters, not string elements.
    wregex wrx2(LR"(\d{4}(-|/)\d{2}(-|/)\d{2})");
    if (regex_match(target3, wideMatch2, wrx2))
    {
        wcout << L"Matching text: " << wideMatch2.str() << endl;
    }

     return 0;
}

Regex found in abc
The matching text is: Hello
Regex found in Drizzle
The matching text is: 2014-04-02

`regex_replace`

Zamienia dopasowane wyrażenia regularne.

template <class OutIt, class BidIt, class RXtraits, class Alloc, class Elem>
OutIt regex_replace(
    OutIt out,
    BidIt first,
    BidIt last,
    const basic_regex<Elem, RXtraits, Alloc>& re,
    const basic_string<Elem>& fmt,
    match_flag_type flags = match_default);

template <class RXtraits, class Alloc, class Elem>
basic_string<Elem> regex_replace(
    const basic_string<Elem>& str,
    const basic_regex<Elem, RXtraits, Alloc>& re,
    const basic_string<Elem>& fmt,
    match_flag_type flags = match_default);

Parametry

OutIt
Typ iteratora dla zamian.

BidIt
Typ iteratora dla podmatów.

RXtraits
Klasa cech dla elementów.

Alloc
Klasa alokatora wyrażeń regularnych.

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

flags
Flagi dopasowań.

first
Początek sekwencji do dopasowania.

fmt
Format zamian.

last
Koniec sekwencji, która ma być zgodna.

out
Iterator danych wyjściowych.

re
Wyrażenie regularne do dopasowania.

str
Ciąg do dopasowania.

Uwagi

Pierwsza funkcja konstruuje regex_iterator obiekt iter(first, last, re, flags) Class i używa go do dzielenia zakresu [first, last) danych wejściowych na serię podsekwencjonów T0 M0 T1 M1...TN-1 MN-1 TN, gdzie Mn jest n-pasmem wykrytym przez iterator. Jeśli nie znaleziono dopasowań, T0 to cały zakres danych wejściowych i N ma wartość zero. Jeśli (flags & format_first_only) != 0 jest używane tylko pierwsze dopasowanie, T1 jest to cały tekst wejściowy zgodny z dopasowaniem i N jest 1. Dla każdego i w zakresie [0, N), jeśli (flags & format_no_copy) == 0 kopiuje tekst w zakresie Ti do iteratora out. Następnie wywołuje m.format(out, fmt, flags)metodę match_results , gdzie m obiekt zwracany przez obiekt iter iteratora dla podsekwencjonowania Mi. Na koniec, jeśli (flags & format_no_copy) == 0 kopiuje tekst w zakresie TN do iteratora out. Funkcja zwraca outwartość .

Druga funkcja tworzy lokalną zmienną result typu basic_string<charT> i wywołuje metodę regex_replace(back_inserter(result), str.begin(), str.end(), re, fmt, flags). Zwraca wartość result.

Przykład

// std__regex__regex_replace.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>

int main()
{
    char buf[20];
    const char *first = "axayaz";
    const char *last = first + strlen(first);
    std::regex rx("a");
    std::string fmt("A");
    std::regex_constants::match_flag_type fonly =
        std::regex_constants::format_first_only;

    *std::regex_replace(&buf[0], first, last, rx, fmt) = '\0';
    std::cout << "replacement == " << &buf[0] << std::endl;

    *std::regex_replace(&buf[0], first, last, rx, fmt, fonly) = '\0';
    std::cout << "replacement == " << &buf[0] << std::endl;

    std::string str("adaeaf");
    std::cout << "replacement == "
        << std::regex_replace(str, rx, fmt) << std::endl;

    std::cout << "replacement == "
        << std::regex_replace(str, rx, fmt, fonly) << std::endl;

    return (0);
}

replacement == AxAyAz
replacement == Axayaz
replacement == AdAeAf
replacement == Adaeaf

`regex_search`

Wyszukuje dopasowanie wyrażenia regularnego.

template <class BidIt, class Alloc, class Elem, class RXtraits, class Alloc2>
bool regex_search(
    BidIt first,
    Bidit last,
    match_results<BidIt, Alloc>& match,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

template <class BidIt, class Elem, class RXtraits, class Alloc2>
bool regex_search(
    BidIt first,
    Bidit last,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

template <class Elem, class Alloc, class RXtraits, class Alloc2>
bool regex_search(
    const Elem* ptr,
    match_results<const Elem*, Alloc>& match,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

template <class Elem, class RXtraits, class Alloc2>
bool regex_search(
    const Elem* ptr,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

template <class IOtraits, class IOalloc, class Alloc, class Elem, class RXtraits, class Alloc2>
bool regex_search(
    const basic_string<Elem, IOtraits, IOalloc>& str,
    match_results<typename basic_string<Elem, IOtraits, IOalloc>::const_iterator, Alloc>& match,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

template <class IOtraits, class IOalloc, class Elem, class RXtraits, class Alloc2>
bool regex_search(
    const basic_string<Elem, IOtraits, IOalloc>& str,
    const basic_regex<Elem, RXtraits, Alloc2>& re,
    match_flag_type flags = match_default);

Parametry

BidIt
Typ iteratora dla podmatów.

Alloc
Klasa alokatora wyników dopasowania.

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

RXtraits
Klasa cech dla elementów.

Alloc2
Klasa alokatora wyrażeń regularnych.

IOtraits
Klasa cech ciągów.

IOalloc
Klasa alokatora ciągów.

flags
Flagi dopasowań.

first
Początek sekwencji do dopasowania.

last
Koniec sekwencji, która ma być zgodna.

match
Wyniki dopasowania.

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

re
Wyrażenie regularne do dopasowania.

str
Ciąg do dopasowania.

Uwagi

Każda funkcja szablonu zwraca wartość true tylko wtedy, gdy wyszukiwanie argumentu wyrażenia re regularnego w sekwencji operandu powiedzie się. Funkcje, które przyjmują match_results obiekt, ustawiają jego elementy członkowskie, aby odzwierciedlić, czy wyszukiwanie zakończyło się pomyślnie, a jeśli tak, różne grupy przechwytywania w wyrażeniu regularnym przechwycone.

Przykład

// std__regex__regex_search.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>

int main()
{
    const char *first = "abcd";
    const char *last = first + strlen(first);
    std::cmatch mr;
    std::regex rx("abc");
    std::regex_constants::match_flag_type fl =
        std::regex_constants::match_default;

    std::cout << "search(f, f+1, \"abc\") == " << std::boolalpha
        << regex_search(first, first + 1, rx, fl) << std::endl;

    std::cout << "search(f, l, \"abc\") == " << std::boolalpha
        << regex_search(first, last, mr, rx) << std::endl;
    std::cout << "  matched: \"" << mr.str() << "\"" << std::endl;

    std::cout << "search(\"a\", \"abc\") == " << std::boolalpha
        << regex_search("a", rx) << std::endl;

    std::cout << "search(\"xabcd\", \"abc\") == " << std::boolalpha
        << regex_search("xabcd", mr, rx) << std::endl;
    std::cout << "  matched: \"" << mr.str() << "\"" << std::endl;

    std::cout << "search(string, \"abc\") == " << std::boolalpha
        << regex_search(std::string("a"), rx) << std::endl;

    std::string str("abcabc");
    std::match_results<std::string::const_iterator> mr2;
    std::cout << "search(string, \"abc\") == " << std::boolalpha
        << regex_search(str, mr2, rx) << std::endl;
    std::cout << "  matched: \"" << mr2.str() << "\"" << std::endl;

    return (0);
}

search(f, f+1, "abc") == false
search(f, l, "abc") == true
  matched: "abc"
search("a", "abc") == false
search("xabcd", "abc") == true
  matched: "abc"
search(string, "abc") == false
search(string, "abc") == true
  matched: "abc"

`swap`

Zamienia dwa basic_regex obiekty lub match_results .

template <class Elem, class RXtraits>
void swap(
    basic_regex<Elem, RXtraits, Alloc>& left,
    basic_regex<Elem, RXtraits>& right) noexcept;

template <class Elem, class IOtraits, class BidIt, class Alloc>
void swap(
    match_results<BidIt, Alloc>& left,
    match_results<BidIt, Alloc>& right) noexcept;

Parametry

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

RXtraits
Klasa cech dla elementów.

Uwagi

Funkcje szablonu zamieniają zawartość odpowiednich argumentów w stałym czasie i nie zgłaszają wyjątków.

Przykład

// std__regex__swap.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>

int main()
{
    std::regex rx0("c(a*)|(b)");
    std::regex rx1;
    std::cmatch mr0;
    std::cmatch mr1;

    swap(rx0, rx1);
    std::regex_search("xcaaay", mr1, rx1);
    swap(mr0, mr1);

    std::csub_match sub = mr0[1];
    std::cout << "matched == " << std::boolalpha
        << sub.matched << std::endl;
    std::cout << "length == " << sub.length() << std::endl;
    std::cout << "string == " << sub << std::endl;

    return (0);
}

matched == true
length == 3
string == aaa

Zobacz też

<regex>
regex_constants Klasa
regex_error Klasa
regex_iterator Klasa
<regex>, operatory
regex_token_iterator Klasa
regex_traits Klasa
<regex>, definicje typów

Udostępnij za pośrednictwem

`<regex>`, funkcje

`regex_match`

Parametry

Uwagi

Przykład

`regex_replace`

Parametry

Uwagi

Przykład

`regex_search`

Parametry

Uwagi

Przykład

`swap`

Parametry

Uwagi

Przykład

Zobacz też

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

<regex>, funkcje

regex_match

Parametry

Uwagi

Przykład

regex_replace

Parametry

Uwagi

Przykład

regex_search

Parametry

Uwagi

Przykład

swap

Parametry

Uwagi

Przykład

Zobacz też

Opinia

Dodatkowe zasoby

`<regex>`, funkcje

`regex_match`

`regex_replace`

`regex_search`

`swap`