basic_regex-Klasse
Umschließt einen regulären Ausdruck.
Syntax
template <class Elem, class RXtraits>
class basic_regex
Parameter
Elem
Der zu entsprechende Elementtyp.
RX-Merkmale
Merkmalklasse für Elemente.
Hinweise
Die Klassenvorlage beschreibt ein Objekt, das einen regulären Ausdruck enthält. Objekte dieser Klassenvorlage können an die Vorlagenfunktionen regex_match, regex_search und regex_replace übergeben werden. Außerdem werden die geeigneten Textzeichenfolgenargumente übergeben, um nach Text zu suchen, der dem regulären Ausdruck entspricht. Es gibt zwei Spezialisierungen dieser Klassenvorlage, mit den Typdefinitionen regex für Elemente vom Typ charund wregex für Elemente des Typs wchar_t.
Das Vorlagenargument RX-Eigenschaften beschreibt verschiedene wichtige Eigenschaften der Syntax der regulären Ausdrücke, die von der Klassenvorlage unterstützt werden. Eine Klasse, die diese Merkmale regulärer Ausdrücke angibt, muss dieselbe externe Schnittstelle wie ein Objekt vom Typ regex_traits Class aufweisen.
Einige Funktionen akzeptieren eine Operandensequenz, die einen regulären Ausdruck definiert. Sie können eine solche Operandensequenz wie folgt angeben:
ptr: eine mit Null beendete Sequenz (z. B. eine C-Zeichenfolge, für Elem vom Typ char) beginnend bei ptr (die kein Nullzeiger sein darf), wobei das Endelement der Wert value_type() ist und nicht Teil der Operandensequenz ist
ptr, : counteine Abfolge von count Elementen ab ptr (die kein Nullzeiger sein darf)
str: die vom basic_string Objekt angegebene Sequenz str
first, : lasteine Abfolge von Elementen, die durch die Iteratoren first und last, im Bereich getrennt sind [first, last)
right: das basic_regex Objekt right
Die obigen Memberfunktionen verwenden auch ein Argument flags , das verschiedene Optionen für die Interpretation des regulären Ausdrucks sowie optionen angibt, die vom RX-Eigenschaftentyp beschrieben werden.
Member
| Member | Standardwert |
|---|---|
| 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 |
| Öffentliche statische Konst flag_type sortieren | regex_constants::collate |
| public static const flag_type ECMAScript | regex_constants::ECMAScript |
| Öffentliche statische Konst flag_type Basic | regex_constants::basic |
| öffentliche statische flag_type erweitert | 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 |
| Private RX-Merkmale |
Konstruktoren
| Konstruktor | Beschreibung |
|---|---|
| basic_regex | Konstruiert das reguläre Ausdrucksobjekt. |
TypeDefs
| Typname | Beschreibung |
|---|---|
| flag_type | Der Typ der Syntaxoptionsflags. |
| locale_type | Der Typ des gespeicherten Gebietsschemaobjekts. |
| value_type | Der Elementtyp. |
Memberfunktionen
| Memberfunktion | Beschreibung |
|---|---|
| assign | Weist dem Objekt für einen regulären Ausdruck einen Wert zu. |
| flags | Gibt Syntaxoptionsflags zurück. |
| getloc | Gibt das gespeicherte Gebietsschemaobjekt zurück. |
| imbue | Ändert das gespeicherte Gebietsschemaobjekt. |
| mark_count | Gibt die Anzahl der übereinstimmenden Teilausdrücke zurück. |
| swap | Tauscht zwei Objekte mit regulärem Ausdruck. |
Operatoren
| Operator | Beschreibung |
|---|---|
| operator= | Weist dem Objekt für einen regulären Ausdruck einen Wert zu. |
Anforderungen
Header:<regex>
Namespace: std
Beispiel
// 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
Weist dem Objekt für einen regulären Ausdruck einen Wert zu.
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);
Parameter
STtraits
Merkmalklasse für eine Zeichenfolgequelle.
STalloc
Zuweisungsklasse für eine Zeichenfolgequelle.
Init
Eingabeiteratortyp für eine Bereichsquelle.
right
Zu kopierende RegEx-Quelle.
ptr
Zeiger zum Anfang der zu kopierenden Sequenz.
flags
Syntaxoptionsflags, die beim Kopieren hinzugefügt werden.
len/TD>
Länge der zu kopierenden Sequenz.
str
Zu kopierende Zeichenfolge.
first
Anfang der zu kopierenden Sequenz.
last
Ende der zu kopierenden Sequenz.
IList
Das zu kopierende initializer_list-Element.
Hinweise
Jede Memberfunktion ersetzt den regulären Ausdruck, der in *this enthalten ist durch den regulären Ausdruck, der in der Operandensequenz enthalten ist und gibt dann *this zurück.
basic_regex::basic_regex
Konstruiert das reguläre Ausdrucksobjekt.
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);
Parameter
STtraits
Merkmalklasse für eine Zeichenfolgequelle.
STalloc
Zuweisungsklasse für eine Zeichenfolgequelle.
Init
Eingabeiteratortyp für eine Bereichsquelle.
right
Zu kopierende RegEx-Quelle.
ptr
Zeiger zum Anfang der zu kopierenden Sequenz.
flags
Syntaxoptionsflags, die beim Kopieren hinzugefügt werden.
len/TD>
Länge der zu kopierenden Sequenz.
str
Zu kopierende Zeichenfolge.
first
Anfang der zu kopierenden Sequenz.
last
Ende der zu kopierenden Sequenz.
IList
Das zu kopierende initializer_list-Element.
Hinweise
Alle Konstruktoren speichern ein standardmäßig erstelltes Objekt vom Typ RXtraits.
Der erste Konstruktor erstellt ein leeres basic_regex-Objekt. Die anderen Konstruktoren erstellen ein basic_regex-Objekt, das den regulären Ausdruck enthält, der von der Operandensequenz beschrieben wird.
Ein leeres basic_regex Objekt stimmt nicht mit einer Zeichenfolge überein, wenn es an regex_match, regex_search oder regex_replace übergeben wird.
basic_regex::flag_type
Der Typ der Syntaxoptionsflags.
typedef regex_constants::syntax_option_type flag_type;
Hinweise
Der Typ ist ein Synonym für regex_constants::syntax_option_type.
basic_regex::flags
Gibt Syntaxoptionsflags zurück.
flag_type flags() const;
Hinweise
Die Memberfunktion gibt den Wert des flag_type-Arguments zurück, das an den letzten Aufruf einer der basic_regex::assign-Memberfunktionen übergeben wurde. Wenn kein Aufruf erfolgt ist, wird der an den Konstruktor übergebene Wert zurückgegeben.
basic_regex::getloc
Gibt das gespeicherte Gebietsschemaobjekt zurück.
locale_type getloc() const;
Hinweise
Die Memberfunktion gibt traits.regex_traits::getloc() zurück.
basic_regex::imbue
Ändert das gespeicherte Gebietsschemaobjekt.
locale_type imbue(locale_type loc);
Parameter
Loc
Das zu speichernde Gebietsschemaobjekt.
Hinweise
Die Memberfunktion leert *this und gibt traits.regex_traits::imbue(loc) zurück.
basic_regex::locale_type
Der Typ des gespeicherten Gebietsschemaobjekts.
typedef typename RXtraits::locale_type locale_type;
Hinweise
Der Typ ist ein Synonym für regex_traits::locale_type.
basic_regex::mark_count
Gibt die Anzahl der übereinstimmenden Teilausdrücke zurück.
unsigned mark_count() const;
Hinweise
Die Memberfunktion gibt die Anzahl der Erfassungsgruppen im regulären Ausdruck zurück.
basic_regex::operator=
Weist dem Objekt für einen regulären Ausdruck einen Wert zu.
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);
Parameter
STtraits
Merkmalklasse für eine Zeichenfolgequelle.
STalloc
Zuweisungsklasse für eine Zeichenfolgequelle.
right
Zu kopierende RegEx-Quelle.
str
Zu kopierende Zeichenfolge.
Hinweise
Jeder Operator ersetzt den regulären Ausdruck, der in *this enthalten ist, durch den regulären Ausdruck, der in der Operandensequenz enthalten ist, und gibt dann *thiszurück.
basic_regex::swap
Tauscht zwei Objekte mit regulärem Ausdruck.
void swap(basic_regex& right) throw();
Parameter
right
Das Objekt mit regulärem Ausdruck, gegen das getauscht werden soll.
Hinweise
Die Memberfunktion tauscht die regulären Ausdrücke zwischen *this und rechts aus. Die Funktion führt dies in konstanter Zeit aus und löst keine Ausnahmen aus.
basic_regex::value_type
Der Elementtyp.
typedef Elem value_type;
Hinweise
Der Typ ist ein Synonym für den Vorlagenparameter Elem.
Siehe auch
<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits-Klasse
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für