Classe basic_regex
Esegue il wrapping di un'espressione regolare.
Sintassi
template <class Elem, class RXtraits>
class basic_regex
Parametri
Elem
Tipo di elementi di cui trovare una corrispondenza.
RXtraits
Classe traits per gli elementi.
Osservazioni:
Il modello di classe descrive un oggetto che contiene un'espressione regolare. Gli oggetti di questo modello di classe possono essere passati alle funzioni modello regex_match, regex_search e regex_replace. Passa anche gli argomenti della stringa di testo appropriati per cercare testo corrispondente all'espressione regolare. Esistono due specializzazioni di questo modello di classe, con le definizioni di tipo regex per gli elementi di tipo chare wregex per gli elementi di tipo wchar_t.
L'argomento modello RXtraits descrive varie proprietà importanti della sintassi delle espressioni regolari supportate dal modello di classe. Una classe che specifica questi tratti di espressione regolare deve avere la stessa interfaccia esterna di un oggetto di tipo regex_traits Class.
Alcune funzioni accettano una sequenza di operandi che definisce un'espressione regolare. È possibile specificare tale sequenza di operandi in diversi modi:
ptr: sequenza con terminazione Null (ad esempio una stringa C, per Elem di tipo char) a partire da ptr (che non deve essere un puntatore Null), dove l'elemento di terminazione è il valore value_type() e non fa parte della sequenza dell'operando
ptr, count: sequenza di count elementi che iniziano da ptr (che non deve essere un puntatore Null)
str: la sequenza specificata dall'oggetto basic_stringstr
first, last: sequenza di elementi delimitati dagli iteratori first e last, nell'intervallo [first, last)
right: oggetto basic_regexright
Le funzioni membro precedenti accettano anche un argomento flags che specifica varie opzioni per l'interpretazione dell'espressione regolare oltre alle opzioni descritte dal tipo RXtraits .
Membri
| Membro | Valore predefinito |
|---|---|
| public static const flag_type icase | regex_constants::icase |
| public static const flag_type nosubs | regex_constants::nosubs |
| public static const flag_type optimize | regex_constants::optimize |
| public static const flag_type collate | regex_constants::collate |
| public static const flag_type ECMAScript | regex_constants::ECMAScript |
| public static const flag_type basic | regex_constants::basic |
| public static const flag_type extended | regex_constants::extended |
| public static const flag_type awk | regex_constants::awk |
| public static const flag_type grep | regex_constants::grep |
| public static const flag_type egrep | regex_constants::egrep |
| tratti RXtraits privati |
Costruttori
| Costruttore | Descrizione |
|---|---|
| basic_regex | Costruisce l'oggetto dell'espressione regolare. |
Typedef
| Nome tipo | Descrizione |
|---|---|
| flag_type | Tipo di flag delle opzioni della sintassi. |
| locale_type | Tipo dell'oggetto impostazioni locali archiviato. |
| value_type | Tipo dell'elemento. |
Funzioni membro
| Funzione membro | Descrizione |
|---|---|
| assign | Assegna un valore all'oggetto di espressione regolare. |
| flags | Restituisce i flag delle opzioni della sintassi. |
| getloc | Restituisce l'oggetto delle impostazioni locali archiviate. |
| imbue | Modifica l'oggetto delle impostazioni locali archiviate. |
| mark_count | Restituisce il numero di sottoespressioni corrispondenti. |
| swap | Scambia due oggetti di espressione regolare. |
Operatori
| Operatore | Descrizione |
|---|---|
| operator= | Assegna un valore all'oggetto di espressione regolare. |
Requisiti
Header:<regex>
Spazio dei nomi: std
Esempio
// 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
Assegna un valore all'oggetto di espressione regolare.
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);
Parametri
STtraits
Classe traits per un'origine di stringa.
STalloc
Classe allocator per un'origine di stringa.
Init
Tipo di iteratore di input per un'origine di intervallo.
right
Origine regex da copiare.
ptr
Puntatore all'inizio della sequenza da copiare.
flags
Flag di opzione sintassi da aggiungere durante la copia.
len/TD>
Lunghezza della sequenza da copiare.
str
Stringa da copiare.
first
Inizio della sequenza da copiare.
last
Fine della sequenza da copiare.
IList
Initializer_list da copiare.
Osservazioni:
Ciascuna funzione membro sostituisce l'espressione regolare contenuta in *this con l'espressione regolare descritta dalla sequenza di operandi, quindi restituisce *this.
basic_regex::basic_regex
Costruisce l'oggetto dell'espressione regolare.
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);
Parametri
STtraits
Classe traits per un'origine di stringa.
STalloc
Classe allocator per un'origine di stringa.
Init
Tipo di iteratore di input per un'origine di intervallo.
right
Origine regex da copiare.
ptr
Puntatore all'inizio della sequenza da copiare.
flags
Flag di opzione sintassi da aggiungere durante la copia.
len/TD>
Lunghezza della sequenza da copiare.
str
Stringa da copiare.
first
Inizio della sequenza da copiare.
last
Fine della sequenza da copiare.
IList
Initializer_list da copiare.
Osservazioni:
Tutti i costruttori archiviano un oggetto costruito predefinito di tipo RXtraits.
Il primo costruttore crea un oggetto basic_regex vuoto. Gli altri costruttori creano un oggetto basic_regex che contiene l'espressione regolare descritta dalla sequenza di operandi.
Un oggetto vuoto basic_regex non corrisponde ad alcuna sequenza di caratteri quando viene passata a regex_match, regex_search o regex_replace.
basic_regex::flag_type
Tipo di flag delle opzioni della sintassi.
typedef regex_constants::syntax_option_type flag_type;
Osservazioni:
Il tipo è sinonimo di regex_constants::syntax_option_type.
basic_regex::flags
Restituisce i flag delle opzioni della sintassi.
flag_type flags() const;
Osservazioni:
La funzione membro restituisce il valore dell'argomento flag_type passato all'ultima chiamata a una delle funzioni membro basic_regex::assign oppure, se non è stata effettuata alcuna chiamata, il valore passato al costruttore.
basic_regex::getloc
Restituisce l'oggetto delle impostazioni locali archiviate.
locale_type getloc() const;
Osservazioni:
La funzione membro restituisce traits.regex_traits::getloc().
basic_regex::imbue
Modifica l'oggetto delle impostazioni locali archiviate.
locale_type imbue(locale_type loc);
Parametri
Loc
Oggetto impostazioni locali da archiviare.
Osservazioni:
La funzione membro svuota *this e restituisce traits.regex_traits::imbue(loc).
basic_regex::locale_type
Tipo dell'oggetto impostazioni locali archiviato.
typedef typename RXtraits::locale_type locale_type;
Osservazioni:
Il tipo è sinonimo di regex_traits::locale_type.
basic_regex::mark_count
Restituisce il numero di sottoespressioni corrispondenti.
unsigned mark_count() const;
Osservazioni:
La funzione membro restituisce il numero di gruppi Capture nell'espressione regolare.
basic_regex::operator=
Assegna un valore all'oggetto di espressione regolare.
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);
Parametri
STtraits
Classe traits per un'origine di stringa.
STalloc
Classe allocator per un'origine di stringa.
right
Origine regex da copiare.
str
Stringa da copiare.
Osservazioni:
Ciascun operatore sostituisce l'espressione regolare contenuta in *this con l'espressione regolare descritta dalla sequenza di operandi, quindi restituisce *this.
basic_regex::swap
Scambia due oggetti di espressione regolare.
void swap(basic_regex& right) throw();
Parametri
right
L'oggetto di espressione regolare con cui eseguire lo scambio.
Osservazioni:
La funzione membro scambia le espressioni regolari tra *this e a destra. Esegue tale operazione in un tempo costante e non genera eccezioni.
basic_regex::value_type
Tipo dell'elemento.
typedef Elem value_type;
Osservazioni:
Il tipo è un sinonimo del parametro modello Elem.
Vedi anche
<regex>
regex_match
regex_search
regex_replace
regex
wregex
Classe regex_traits