`<regex>` – funkce

Článek
10/12/2023

Název	Popis
`regex_match`	Testuje, zda regulární výraz odpovídá celému cílovému řetězci.
`regex_replace`	Nahradí odpovídající regulární výrazy.
`regex_search`	Vyhledá shodu regulárního výrazu.
`swap`	Prohodí dva `basic_regex` objekty nebo `match_results` objekty.

`regex_match`

Testuje, zda regulární výraz odpovídá celému cílovému řetězci.

// (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 iterátoru pro podsložky. U běžných případů je to jeden z string::const_iterator, const char* wstring::const_iteratornebo const wchar_t*.

Alloc
Shoda výsledků alokátoru – třída.

Elem
Typ prvků, které se mají spárovat. V běžných případech se jedná stringo , char* wstringnebo wchar_t*.

RXtraits
Třída vlastností prvků.

Alloc2
Třída alokátoru regulárního výrazu.

IOtraits
Třída řetězcových vlastností.

IOalloc
Třída alokátoru řetězců.

flags
Příznaky pro shody.

first
Začátek sekvence, která se má shodovat.

last
Konec sekvence, která se má shodovat.

match
Výsledky shody. Odpovídá typu Elem: smatch pro string, wsmatch pro wstring, cmatch pro char* nebo wcmatch pro wchar_t*.

ptr
Ukazatel na začátek sekvence, která se má shodovat. Pokud ptr je char*, pak použijte cmatch a regex. Pokud ptr je wchar_t* pak použit wcmatch a wregex.

re
Regulární výraz, který se má shodovat. Zadejte regex pro string a char*, nebo wregex pro wstring a wchar_t*.

str
Řetězec, který se má shodovat. Odpovídá typu .Elem

Poznámky

Každá funkce šablony vrátí hodnotu true pouze v případě, že celá sekvence str operandu přesně odpovídá argumentu regulárního výrazu re. Slouží regex_search k porovnávání podřetětědce v cílové sekvenci a regex_iterator k vyhledání více shod. Funkce, které přebírají match_results objekt nastaveny jeho členy, aby odrážely, zda shoda proběhla úspěšně, a pokud ano, jaké různé skupiny zachycení v regulárním výrazu byly zachyceny.

Funkce, které přebírají match_results objekt nastaveny jeho členy, aby odrážely, zda shoda proběhla úspěšně, a pokud ano, jaké různé skupiny zachycení v regulárním výrazu byly zachyceny.

Příklad

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

Nahradí odpovídající regulární výrazy.

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 iterátoru pro nahrazení.

BidIt
Typ iterátoru pro podsložky.

RXtraits
Třída vlastností prvků.

Alloc
Třída alokátoru regulárního výrazu.

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

flags
Příznaky pro shody.

first
Začátek sekvence, která se má shodovat.

fmt
Formát pro nahrazení.

last
Konec sekvence, která se má shodovat.

out
Výstupní iterátor.

re
Regulární výraz, který se má shodovat.

str
Řetězec, který se má shodovat.

Poznámky

První funkce vytvoří objekt Třídy a použije ho k rozdělení vstupního rozsahu [first, last) do řady dílčích T0 M0 T1 M1...TN-1 MN-1 TNsekvencí , kde Mn je nth shoda zjištěná iterátorem. iter(first, last, re, flags)regex_iterator Pokud se nenajde žádná shoda, T0 je celá vstupní oblast a N je nulová. Pokud (flags & format_first_only) != 0 se použije pouze první shoda, T1 je veškerý vstupní text, který následuje za shodou, a N je 1. Pro každý i v oblasti [0, N), pokud (flags & format_no_copy) == 0 zkopíruje text v oblasti Ti do iterátoru out. Potom volá m.format(out, fmt, flags), kde m je match_results objekt vrácen objektem iterátoru iter pro dílčí sekvenci Mi. A nakonec, pokud (flags & format_no_copy) == 0 zkopíruje text v oblasti TN do iterátoru out. Funkce vrátí out.

Druhá funkce vytvoří místní proměnnou result typu basic_string<charT> a volání regex_replace(back_inserter(result), str.begin(), str.end(), re, fmt, flags). resultVrátí .

Příklad

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

Vyhledá shodu regulárního výrazu.

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 iterátoru pro podsložky.

Alloc
Shoda výsledků alokátoru – třída.

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

RXtraits
Třída vlastností prvků.

Alloc2
Třída alokátoru regulárního výrazu.

IOtraits
Třída řetězcových vlastností.

IOalloc
Třída alokátoru řetězců.

flags
Příznaky pro shody.

first
Začátek sekvence, která se má shodovat.

last
Konec sekvence, která se má shodovat.

match
Výsledky shody.

ptr
Ukazatel na začátek sekvence, která se má shodovat.

re
Regulární výraz, který se má shodovat.

str
Řetězec, který se má shodovat.

Poznámky

Každá funkce šablony vrátí hodnotu true pouze v případě, že hledání argumentu re regulárního výrazu v pořadí operandů proběhne úspěšně. Funkce, které přebírají match_results objekt, nastaví jeho členy tak, aby odrážely, zda hledání proběhlo úspěšně, a pokud ano, jaké různé skupiny zachycení v regulárním výrazu byly zachyceny.

Příklad

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

Prohodí dva basic_regex objekty nebo match_results objekty.

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 prvků, které se mají spárovat.

RXtraits
Třída vlastností prvků.

Poznámky

Funkce šablony prohodí obsah příslušných argumentů v konstantním čase a nevyvolají výjimky.

Příklad

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

Viz také

<regex>
regex_constants Třída
regex_error Třída
regex_iterator Třída
<regex> – operátory
regex_token_iterator Třída
regex_traits Třída
<regex> – definice Typedef

Sdílet prostřednictvím

`<regex>` – funkce

`regex_match`

Parametry

Poznámky

Příklad

`regex_replace`

Parametry

Poznámky

Příklad

`regex_search`

Parametry

Poznámky

Příklad

`swap`

Parametry

Poznámky

Příklad

Viz také

Váš názor

Další materiály

Sdílet prostřednictvím

<regex> – funkce

regex_match

Parametry

Poznámky

Příklad

regex_replace

Parametry

Poznámky

Příklad

regex_search

Parametry

Poznámky

Příklad

swap

Parametry

Poznámky

Příklad

Viz také

Váš názor

Další materiály

`<regex>` – funkce

`regex_match`

`regex_replace`

`regex_search`

`swap`