Classe match_results

Contiene una sequenza delle sottocorrispondenze.

Sintassi

template <class BidIt, class Alloc>
class match_results

Parametri

BidIt
Tipo di iteratore per le sottocorrispondenze.

Alloc
Tipo di un allocatore per gestire l'archiviazione.

Osservazioni:

Il modello di classe descrive un oggetto che controlla una sequenza non modificabile di elementi di tipo sub_match<BidIt> generato da una ricerca di espressioni regolari. Ogni elemento punta alla sottosequenza corrispondente al gruppo Capture corrispondente a tale elemento.

Costruttori

Costruttore	Descrizione
match_results	Costruisce l'oggetto.

Typedef

Nome tipo	Descrizione
allocator_type	Tipo di un allocatore per gestire l'archiviazione.
char_type	Tipo di un elemento.
const_iterator	Tipo di iteratore const per le sottocorrispondenze.
const_reference	Il tipo di un riferimento const dell'elemento.
difference_type	Tipo di differenza iteratore.
iterator	Tipo di iteratore per le sottocorrispondenze.
reference	Tipo di un riferimento dell'elemento.
size_type	Tipo di un conteggio delle sottocorrispondenze.
string_type	Tipo di una stringa.
value_type	Tipo di una sottocorrispondenza.

Funzioni membro

Funzione membro	Descrizione
begin	Definisce l'inizio di una sequenza di sottocorrispondenze.
empty	Verifica che non siano presenti sottocorrispondenze.
end	Definisce la fine di una sequenza di sottocorrispondenze.
format	Formatta le sottocorrispondenze.
get_allocator	Restituisce l'allocatore archiviato.
length	Restituisce la lunghezza di una sottocorrispondenza.
max_size	Ottiene il numero massimo delle sottocorrispondenze.
position	Ottiene l'offset iniziale di un sottogruppo.
prefix	Ottiene la sequenza prima della prima sottocorrispondenza.
size	Conteggia il numero di sottocorrispondenze.
str	Restituisce una sottocorrispondenza.
suffix	Ottiene la sequenza dopo l'ultima sottocorrispondenza.
swap	Scambia due oggetti match_results.

Operatori

Operatore	Descrizione
operator=	Copia un oggetto match_results.
operator[]	Accede a un oggetto secondario.

Requisiti

Header:<regex>

Spazio dei nomi: std

Esempio

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

int main()
{
    std::regex rx("c(a*)|(b)");
    std::cmatch mr;

    std::regex_search("xcaaay", mr, rx);

    std::cout << "prefix: matched == " << std::boolalpha
        << mr.prefix().matched
        << ", value == " << mr.prefix() << std::endl;
    std::cout << "whole match: " << mr.length() << " chars, value == "
        << mr.str() << std::endl;
    std::cout << "suffix: matched == " << std::boolalpha
        << mr.suffix().matched
        << ", value == " << mr.suffix() << std::endl;
    std::cout << std::endl;

    std::string fmt("\"c(a*)|(b)\" matched \"$&\"\n"
        "\"(a*)\" matched \"$1\"\n"
        "\"(b)\" matched \"$2\"\n");
    std::cout << mr.format(fmt) << std::endl;
    std::cout << std::endl;

    // index through submatches
    for (size_t n = 0; n < mr.size(); ++n)
    {
        std::cout << "submatch[" << n << "]: matched == " << std::boolalpha
            << mr[n].matched <<
            " at position " << mr.position(n) << std::endl;
        std::cout << "  " << mr.length(n)
            << " chars, value == " << mr[n] << std::endl;
    }
    std::cout << std::endl;

    // iterate through submatches
    for (std::cmatch::iterator it = mr.begin(); it != mr.end(); ++it)
    {
        std::cout << "next submatch: matched == " << std::boolalpha
            << it->matched << std::endl;
        std::cout << "  " << it->length()
            << " chars, value == " << *it << std::endl;
    }
    std::cout << std::endl;

    // other members
    std::cout << "empty == " << std::boolalpha << mr.empty() << std::endl;

    std::cmatch::allocator_type al = mr.get_allocator();
    std::cmatch::string_type str = std::string("x");
    std::cmatch::size_type maxsiz = mr.max_size();
    std::cmatch::char_type ch = 'x';
    std::cmatch::difference_type dif = mr.begin() - mr.end();
    std::cmatch::const_iterator cit = mr.begin();
    std::cmatch::value_type val = *cit;
    std::cmatch::const_reference cref = val;
    std::cmatch::reference ref = val;

    maxsiz = maxsiz;  // to quiet "unused" warnings
    if (ref == cref)
        ch = ch;
    dif = dif;

    return (0);
}

prefix: matched == true, value == x
whole match: 4 chars, value == caaa
suffix: matched == true, value == y

"c(a*)|(b)" matched "caaa"
"(a*)" matched "aaa"
"(b)" matched ""

submatch[0]: matched == true at position 1
  4 chars, value == caaa
submatch[1]: matched == true at position 2
  3 chars, value == aaa
submatch[2]: matched == false at position 6
  0 chars, value ==

next submatch: matched == true
  4 chars, value == caaa
next submatch: matched == true
  3 chars, value == aaa
next submatch: matched == false
  0 chars, value ==

empty == false

match_results::allocator_type

Tipo di un allocatore per gestire l'archiviazione.

typedef Alloc allocator_type;

Osservazioni:

Typedef è un sinonimo dell'argomento modello Alloc.

match_results::begin

Definisce l'inizio di una sequenza di sottocorrispondenze.

const_iterator begin() const;

Osservazioni:

La funzione membro restituisce un iteratore di accesso casuale che punta al primo elemento della sequenza (o appena oltre la fine di una sequenza vuota).

match_results::char_type

Tipo di un elemento.

typedef typename iterator_traits<BidIt>::value_type char_type;

Osservazioni:

typedef è un sinonimo del tipo iterator_traits<BidIt>::value_type, che corrisponde al tipo di elemento della sequenza di caratteri cercata.

match_results::const_iterator

Tipo di iteratore const per le sottocorrispondenze.

typedef T0 const_iterator;

Osservazioni:

typedef descrive un oggetto che può essere usato come iteratore ad accesso casuale costante per la sequenza controllata.

match_results::const_reference

Il tipo di un riferimento const dell'elemento.

typedef const typename Alloc::const_reference const_reference;

Osservazioni:

Typedef descrive un oggetto che può essere usato come riferimento costante a un elemento della sequenza controllata.

match_results::d ifference_type

Tipo di differenza iteratore.

typedef typename iterator_traits<BidIt>::difference_type difference_type;

Osservazioni:

typedef è un sinonimo del tipo iterator_traits<BidIt>::difference_type; descrive un oggetto che può rappresentare la differenza tra due iteratori che puntano a elementi della sequenza controllata.

match_results::empty

Verifica che non siano presenti sottocorrispondenze.

bool empty() const;

Osservazioni:

La funzione membro restituisce true solo se la ricerca di espressioni regolari non riesce.

match_results::end

Definisce la fine di una sequenza di sottocorrispondenze.

const_iterator end() const;

Osservazioni:

La funzione membro restituisce un iteratore che punta poco oltre la fine della sequenza.

match_results::format

Formatta le sottocorrispondenze.

template <class OutIt>
OutIt format(OutIt out,
    const string_type& fmt, match_flag_type flags = format_default) const;

string_type format(const string_type& fmt, match_flag_type flags = format_default) const;

Parametri

OutIt
Tipo di iteratore di output.

out
Flusso di output in cui scrivere.

Fmt
Stringa di formato.

flags
Flag di formato.

Osservazioni:

Ogni funzione membro genera testo formattato sotto il controllo del formato fmt. La prima funzione membro scrive il testo formattato nella sequenza definita dal relativo argomento e restituisce . La seconda funzione membro restituisce un oggetto stringa contenente una copia del testo formattato.

Per generare testo formattato, il testo letterale della stringa di formato viene in genere copiato nella sequenza di destinazione. Ogni sequenza di escape della stringa di formato viene sostituita con il testo da essa rappresentato. I dettagli delle operazioni di copia e sostituzione vengono controllati dai flag di formato passati alla funzione.

match_results::get_allocator

Restituisce l'allocatore archiviato.

allocator_type get_allocator() const;

Osservazioni:

La funzione membro restituisce una copia dell'oggetto allocatore usato da *this per allocare i relativi oggetti sub_match.

match_results::iterator

Tipo di iteratore per le sottocorrispondenze.

typedef const_iterator iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore ad accesso casuale per la sequenza controllata.

match_results::length

Restituisce la lunghezza di una sottocorrispondenza.

difference_type length(size_type sub = 0) const;

Parametri

sub
Indice della sottocorrispondenza.

Osservazioni:

La funzione membro restituisce(*this)[sub].length().

match_results::match_results

Costruisce l'oggetto.

explicit match_results(const Alloc& alloc = Alloc());

match_results(const match_results& right);

Parametri

alloc
Oggetto allocatore da archiviare.

right
Oggetto match_results da copiare.

Osservazioni:

Il primo costruttore crea un oggetto match_results che non contiene sottocorrispondenze. Il secondo costruttore costruisce un match_results oggetto che è una copia di destra.

match_results::max_size

Ottiene il numero massimo delle sottocorrispondenze.

size_type max_size() const;

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza più lunga che l'oggetto può controllare.

match_results::operator=

Copia un oggetto match_results.

match_results& operator=(const match_results& right);

Parametri

right
Oggetto match_results da copiare.

Osservazioni:

L'operatore membro sostituisce la sequenza controllata da *this con una copia della sequenza controllata da destra.

match_results::operator[]

Accede a un oggetto secondario.

const_reference operator[](size_type n) const;

Parametri

n
Indice della sottocorrispondenza.

Osservazioni:

La funzione membro restituisce un riferimento all'elemento n della sequenza controllata o un riferimento a un oggetto vuoto sub_match se size() <= n o se il gruppo di acquisizione n non fa parte della corrispondenza.

match_results::p osition

Ottiene l'offset iniziale di un sottogruppo.

difference_type position(size_type sub = 0) const;

Parametri

sub
Indice della sottocorrispondenza.

Osservazioni:

La funzione membro restituisce std::distance(prefix().first, (*this)[sub].first), ovvero la distanza tra il primo carattere della sequenza di destinazione e il primo carattere nella sottocorrispondenza a cui punta l'elemento n della sequenza controllata.

match_results::p fix

Ottiene la sequenza prima della prima sottocorrispondenza.

const_reference prefix() const;

Osservazioni:

La funzione membro restituisce un riferimento a un oggetto di tipo sub_match<BidIt> che punta alla sequenza di caratteri che inizia a partire dalla sequenza di destinazione e termina in corrispondenza di (*this)[0].first, ovvero punta al testo che precede la sottosequenza corrispondente.

match_results::reference

Tipo di un riferimento dell'elemento.

typedef const_reference reference;

Osservazioni:

type è un sinonimo del tipo const_reference.

match_results::size

Conteggia il numero di sottocorrispondenze.

size_type size() const;

Osservazioni:

La funzione membro restituisce una corrispondenza più rispetto al numero di gruppi Capture nell'espressione regolare usata per la ricerca oppure zero se non è stata eseguita alcuna ricerca.

match_results::size_type

Tipo di un conteggio delle sottocorrispondenze.

typedef typename Alloc::size_type size_type;

Osservazioni:

type è un sinonimo del tipo Alloc::size_type.

match_results::str

Restituisce una sottocorrispondenza.

string_type str(size_type sub = 0) const;

Parametri

sub
Indice della sottocorrispondenza.

Osservazioni:

La funzione membro restituiscestring_type((*this)[sub]).

match_results::string_type

Tipo di una stringa.

typedef basic_string<char_type> string_type;

Osservazioni:

type è un sinonimo del tipo basic_string<char_type>.

match_results::suffisso

Ottiene la sequenza dopo l'ultima sottocorrispondenza.

const_reference suffix() const;

Osservazioni:

La funzione membro restituisce un riferimento a un oggetto di tipo sub_match<BidIt> che punta alla sequenza di caratteri che inizia a partire da (*this)[size() - 1].second e termina alla fine della sequenza di destinazione, ovvero punta al testo che segue la sottosequenza corrispondente.

match_results::swap

Scambia due oggetti match_results.

void swap(const match_results& right) throw();

Parametri

right
Oggetto match_results con cui effettuare lo scambio.

Osservazioni:

La funzione membro scambia il contenuto di *this e destra nel tempo costante e non genera eccezioni.

match_results::value_type

Tipo di una sottocorrispondenza.

typedef sub_match<BidIt> value_type;

Osservazioni:

typedef è un sinonimo del tipo sub_match<BidIt>.

Vedi anche

<regex>