`<regex>` funzioni

Articolo
10/12/2023

Nome	Descrizione
`regex_match`	Verifica se un'espressione regolare corrisponde all'intera stringa di destinazione.
`regex_replace`	Sostituisce espressioni regolari corrispondenti.
`regex_search`	Cerca una corrispondenza dell'espressione regolare.
`swap`	Scambia due `basic_regex` oggetti o `match_results` .

`regex_match`

Verifica se un'espressione regolare corrisponde all'intera stringa di destinazione.

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

Parametri

BidIt
Tipo di iteratore per le sottocorrispondenze. Per i casi comuni di questo tipo di string::const_iterator, wstring::const_iteratorconst char* o const wchar_t*.

Alloc
Classe allocator dei risultati di corrispondenza.

Elem
Tipo di elementi di cui trovare una corrispondenza. Per i casi comuni, si tratta di string, wstringchar* o wchar_t*.

RXtraits
Classe traits per gli elementi.

Alloc2
Classe allocator dell'espressione regolare.

IOtraits
Classe traits della stringa.

IOalloc
Classe allocator della stringa.

flags
Flag per le corrispondenze.

first
Inizio della sequenza per cui cercare una corrispondenza.

last
Fine della sequenza per cui cercare una corrispondenza.

match
Risultati della corrispondenza. Corrisponde al tipo Elem: smatch per string, wsmatch per wstring, cmatch per char* o wcmatch per wchar_t*.

ptr
Puntatore all'inizio della sequenza per cui cercare una corrispondenza. Se ptr è char*, usare cmatch e regex. Se ptr è wchar_t* quindi usare wcmatch e wregex.

re
Espressione regolare in base a cui trovare una corrispondenza. Digitare regex per string e char*o wregex per wstring e wchar_t*.

str
Stringa per cui cercare una corrispondenza. Corrisponde al tipo di Elem.

Osservazioni:

Ogni funzione modello restituisce true solo se l'intera sequenza di operandi str corrisponde esattamente all'argomento dell'espressione regolare re. Usare regex_search per trovare le corrispondenze con una sottostringa all'interno di una sequenza di destinazione e regex_iterator per trovare più corrispondenze. Le funzioni che accettano un oggetto match_results impostano i propri membri in modo da indicare se la corrispondenza ha avuto esito positivo e, in caso affermativo, cosa hanno acquisito i vari gruppi di acquisizione nell'espressione regolare.

Le funzioni che accettano un oggetto match_results impostano i propri membri in modo da indicare se la corrispondenza ha avuto esito positivo e, in caso affermativo, cosa hanno acquisito i vari gruppi di acquisizione nell'espressione regolare.

Esempio

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

Sostituisce espressioni regolari corrispondenti.

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

Parametri

OutIt
Tipo di iteratore per le sostituzioni.

BidIt
Tipo di iteratore per le sottocorrispondenze.

RXtraits
Classe traits per gli elementi.

Alloc
Classe allocator dell'espressione regolare.

Elem
Tipo di elementi di cui trovare una corrispondenza.

flags
Flag per le corrispondenze.

first
Inizio della sequenza per cui cercare una corrispondenza.

fmt
Formato delle sostituzioni.

last
Fine della sequenza per cui cercare una corrispondenza.

out
Iteratore di output.

re
Espressione regolare in base a cui trovare una corrispondenza.

str
Stringa per cui cercare una corrispondenza.

Osservazioni:

La prima funzione costruisce un oggetto Class e la usa per suddividere l'intervallo [first, last) di input in una serie di sottosequenze T0 M0 T1 M1...TN-1 MN-1 TN, dove Mn è l'ennesima corrispondenza rilevata dall'iteratore. iter(first, last, re, flags)regex_iterator Se non viene trovata alcuna corrispondenza, T0 è l'intero intervallo di input e N è zero. Se (flags & format_first_only) != 0 viene usata solo la prima corrispondenza, T1 è il testo di input che segue la corrispondenza e N è 1. Per ciascun i nell'intervallo [0, N), se (flags & format_no_copy) == 0 il testo verrà copiato nell'intervallo Ti all'iteratore out. Viene quindi chiamato m.format(out, fmt, flags), dove m è l'oggetto match_results restituito dall'oggetto iteratore iter per la sottosequenza Mi. Infine, se (flags & format_no_copy) == 0 il testo verrà copiato nell'intervallo TN all'iteratore out. La funzione restituisce out.

La seconda funzione costruisce una variabile locale result di tipo basic_string<charT> e chiama regex_replace(back_inserter(result), str.begin(), str.end(), re, fmt, flags). Restituisce result.

Esempio

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

Cerca una corrispondenza dell'espressione regolare.

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

Parametri

BidIt
Tipo di iteratore per le sottocorrispondenze.

Alloc
Classe allocator dei risultati di corrispondenza.

Elem
Tipo di elementi di cui trovare una corrispondenza.

RXtraits
Classe traits per gli elementi.

Alloc2
Classe allocator dell'espressione regolare.

IOtraits
Classe traits della stringa.

IOalloc
Classe allocator della stringa.

flags
Flag per le corrispondenze.

first
Inizio della sequenza per cui cercare una corrispondenza.

last
Fine della sequenza per cui cercare una corrispondenza.

match
Risultati della corrispondenza.

ptr
Puntatore all'inizio della sequenza per cui cercare una corrispondenza.

re
Espressione regolare in base a cui trovare una corrispondenza.

str
Stringa per cui cercare una corrispondenza.

Osservazioni:

Ciascuna funzione modello restituisce true solo se la ricerca dell'argomento dell'espressione regolare re nella sequenza di operandi ha esito positivo. Le funzioni che accettano un oggetto match_results impostano i propri membri in modo da indicare se la ricerca ha avuto esito positivo e, in caso affermativo, cosa hanno acquisito i vari gruppi di acquisizione nell'espressione regolare.

Esempio

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

Scambia due basic_regex oggetti o 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;

Parametri

Elem
Tipo di elementi di cui trovare una corrispondenza.

RXtraits
Classe traits per gli elementi.

Osservazioni:

Le funzioni modello scambiano il contenuto dei rispettivi argomenti in tempo costante e non generano eccezioni.

Esempio

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

Vedi anche

<regex>
regex_constants Classe
regex_error Classe
regex_iterator Classe
<regex> Operatori
regex_token_iterator Classe
regex_traits Classe
Typedef <regex>

Condividi tramite

`<regex>` funzioni

`regex_match`

Parametri

Osservazioni:

Esempio

`regex_replace`

Parametri

Osservazioni:

Esempio

`regex_search`

Parametri

Osservazioni:

Esempio

`swap`

Parametri

Osservazioni:

Esempio

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

<regex> funzioni

regex_match

Parametri

Osservazioni:

Esempio

regex_replace

Parametri

Osservazioni:

Esempio

regex_search

Parametri

Osservazioni:

Esempio

swap

Parametri

Osservazioni:

Esempio

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive

`<regex>` funzioni

`regex_match`

`regex_replace`

`regex_search`

`swap`