Grundlagen zu regulären Ausdrücken in C++

Regular Expression Basics C

Betrachten Sie den folgenden Satz in Anführungszeichen:

'Hier ist mein Mann.'

Diese Zeichenfolge kann sich im Computer befinden, und der Benutzer möchte möglicherweise wissen, ob sie das Wort man enthält. Wenn es das Wort Mann enthält, möchte er vielleicht das Wort Mann in Frau ändern; damit die Zeichenfolge lauten sollte:



'Hier ist meine Frau.'

Es gibt viele andere Wünsche wie diese vom Computerbenutzer; manche sind komplex. Regulärer Ausdruck, abgekürzt Regex, ist Gegenstand der Behandlung dieser Probleme durch den Computer. C++ enthält eine Bibliothek namens regex. Ein C++-Programm zur Behandlung von Regex sollte also beginnen mit:



#enthalten

#enthalten

mit namespace std;

In diesem Artikel werden die Grundlagen regulärer Ausdrücke in C++ erläutert.



Artikelinhalt

Grundlagen zu regulären Ausdrücken

Regex

Ein String wie Here is my man. oben ist die Zielsequenz oder Zielzeichenfolge oder einfach Ziel. man, nach dem gesucht wurde, ist der reguläre Ausdruck oder einfach Regex.

Passende

Von einer Übereinstimmung spricht man, wenn das gesuchte Wort oder der gesuchte Ausdruck gefunden wird. Nach dem Matching kann ein Austausch erfolgen. Nachdem sich beispielsweise der Mann oben befindet, kann er durch eine Frau ersetzt werden.

Einfache Zuordnung

Das folgende Programm zeigt, wie das Wort Mann zugeordnet wird.



#enthalten

#enthalten

mit namespace std;

inthauptsächlich()
{

regex reg('Mann');
wenn (regex_search('Hier ist mein Mann.',reg))
Kosten<< 'abgestimmt' <<endl;
anders
Kosten<< 'nicht passend' <<endl;

Rückkehr 0;
}

Die Funktion regex_search() gibt true zurück, wenn eine Übereinstimmung vorliegt, und gibt false zurück, wenn keine Übereinstimmung auftritt. Hier nimmt die Funktion zwei Argumente an: Das erste ist die Zielzeichenfolge und das zweite ist das Regex-Objekt. Die Regex selbst ist 'man' in doppelten Anführungszeichen. Die erste Anweisung in der Funktion main() bildet das Regex-Objekt. Regex ist ein Typ und reg ist das Regex-Objekt. Die Ausgabe des obigen Programms ist 'matched', da 'man' im Zielstring zu sehen ist. Wenn 'man' im Ziel nicht zu sehen wäre, hätte regex_search() false zurückgegeben und die Ausgabe wäre 'not matched' gewesen.

Die Ausgabe des folgenden Codes stimmt nicht überein:

regex reg('Mann');
wenn (regex_search('Hier ist meine Herstellung.',reg))
Kosten<< 'abgestimmt' <<endl;
anders
Kosten<< 'nicht passend' <<endl;

Keine Übereinstimmung, da die Regex 'man' nicht in der gesamten Zielzeichenfolge 'Hier ist meine Herstellung' gefunden werden konnte.

Muster

Der reguläre Ausdruck, Mann oben, ist sehr einfach. Regexes sind normalerweise nicht so einfach. Reguläre Ausdrücke haben Metazeichen. Metazeichen sind Zeichen mit besonderer Bedeutung. Ein Metazeichen ist ein Zeichen über Zeichen. C++ Regex-Metazeichen sind:

^$.* + ? ( ) [ ] { } |

Eine Regex, mit oder ohne Metazeichen, ist ein Muster.

Charakterklassen

Eckige Klammern

Ein Muster kann Zeichen in eckigen Klammern enthalten. Damit würde eine bestimmte Position in der Zielzeichenfolge mit einem der Zeichen der eckigen Klammern übereinstimmen. Betrachten Sie die folgenden Ziele:

'Die Katze ist im Zimmer.'

'Die Fledermaus ist im Zimmer.'

'Die Ratte ist im Zimmer.'

Die Regex [cbr]at würde cat im ersten Ziel entsprechen. Es würde mit der Fledermaus im zweiten Ziel übereinstimmen. Es würde der Ratte im dritten Ziel entsprechen. Dies liegt daran, dass Katze oder Fledermaus oder Ratte mit „c“ oder „b“ oder „r“ beginnen. Das folgende Codesegment veranschaulicht dies:

regex reg('[cbr]at');
wenn (regex_search('Die Katze ist im Zimmer.',reg))
Kosten<< 'abgestimmt' <<endl;
wenn (regex_search('Die Fledermaus ist im Zimmer.',reg))
Kosten<< 'abgestimmt' <<endl;
wenn (regex_search('Die Ratte ist im Zimmer.',reg))
Kosten<< 'abgestimmt' <<endl;

Die Ausgabe ist:

abgestimmt

abgestimmt

abgestimmt

Zeichenbereich

Die Klasse [cbr] im Muster [cbr] würde mit mehreren möglichen Zeichen im Ziel übereinstimmen. Es würde „c“ oder „b“ oder „r“ im Ziel entsprechen. Wenn das Ziel keines von „c“ oder „b“ oder „r“ enthält, gefolgt von at, gibt es keine Übereinstimmung.

Einige Möglichkeiten wie ‚c‘ oder ‚b‘ oder ‚r‘ existieren in einem Bereich. Der Ziffernbereich 0 bis 9 hat 10 Möglichkeiten, und das Muster dafür ist [0-9]. Der Bereich der Kleinbuchstaben von a bis z hat 26 Möglichkeiten, und das Muster dafür ist [a-z]. Der Bereich der Großbuchstaben von A bis Z hat 26 Möglichkeiten, und das Muster dafür ist [A-Z]. – ist offiziell kein Metazeichen, aber in eckigen Klammern würde es einen Bereich angeben. Folgendes ergibt also eine Übereinstimmung:

wenn (regex_search('ID6id',regex('[0-9]')))

Kosten<< 'abgestimmt' <<endl;

Beachten Sie, wie die Regex als zweites Argument konstruiert wurde. Die Übereinstimmung findet zwischen der Ziffer 6 im Bereich 0 bis 9 und der 6 im Ziel ID6id statt. Der obige Code entspricht:

wenn (regex_search('ID6id',regex('[0123456789]')))

Kosten<< 'abgestimmt' <<endl;

Der folgende Code erzeugt eine Übereinstimmung:

verkohlenP[] = 'ID6iE';

wenn (regex_search(P,regex('[a-z]')))

Kosten<< 'abgestimmt' <<endl;

Beachten Sie, dass das erste Argument hier eine Zeichenfolgenvariable und nicht das Zeichenfolgenliteral ist. Die Übereinstimmung liegt zwischen „i“ in [a-z] und „i“ in ID6iE.

Vergessen Sie nicht, dass ein Bereich eine Klasse ist. Im Muster kann sich rechts oder links des Bereichs Text befinden. Der folgende Code erzeugt eine Übereinstimmung:

wenn (regex_search('ID2id ist eine ID',regex('ID[0-9]id')))

Kosten<< 'abgestimmt' <<endl;

Die Übereinstimmung liegt zwischen ID[0-9]id und ID2id. Der Rest der Zielzeichenfolge ist eine ID und stimmt in dieser Situation nicht überein.

Wie im Betreff regulärer Ausdrücke (regexes) verwendet, bedeutet das Wort Klasse eigentlich eine Menge. Das heißt, eines der Zeichen im Satz muss übereinstimmen.

Hinweis: Der Bindestrich – ist ein Metazeichen, das nur in eckigen Klammern steht und einen Bereich angibt. Es ist kein Metazeichen in der Regex, außerhalb der eckigen Klammern.

Negation

Eine Klasse mit einem Bereich kann negiert werden. Das heißt, keines der Zeichen in der Menge (Klasse) sollte übereinstimmen. Dies wird mit dem Metazeichen ^ am Anfang des Klassenmusters direkt nach der öffnenden eckigen Klammer angezeigt. [^0-9] bedeutet also, dass das Zeichen an der entsprechenden Position im Ziel gefunden wird, das kein Zeichen im Bereich von 0 bis einschließlich 9 ist. Der folgende Code erzeugt also keine Übereinstimmung:

wenn (regex_search('0123456789101112',regex('[^ 0-9]')))

Kosten<< 'abgestimmt' <<endl;

anders

Kosten<< 'nicht passend' <<endl;

Eine Ziffer im Bereich von 0 bis 9 kann an jeder der Zielzeichenfolgenpositionen gefunden werden, 0123456789101112; es gibt also keine Übereinstimmung – Negation.

Der folgende Code erzeugt eine Übereinstimmung:

wenn (regex_search('ABCDEFGHIJ',regex('[^ 0-9]')))

Kosten<< 'abgestimmt' <<endl;

Im Ziel ABCDEFGHIJ konnte keine Ziffer gefunden werden; es gibt also eine Übereinstimmung.

[a-z] ist ein Bereich außerhalb von [^a-z]. [^a-z] ist also die Negation von [a-z].

[A-Z] ist ein Bereich außerhalb von [^A-Z]. [^A-Z] ist also die Negation von [A-Z].

Andere Verneinungen existieren.

Passende Leerzeichen

‘ ’ oder oder oder oder f ist ein Leerzeichen. Im folgenden Code entspricht die Regex ‚ ‘ im Ziel:

wenn (regex_search(»Von Linie eins.R Von Zeile zwei.',regex(' ')))

Kosten<< 'abgestimmt' <<endl;

Übereinstimmung mit einem beliebigen Whitespace-Zeichen

Das Muster oder die Klasse, die einem Leerzeichen entspricht, ist [ f]. Im folgenden Code wird ‘ ’ abgeglichen:

wenn (regex_search('eins zwei',regex('[TR F] ')))

Kosten<< 'abgestimmt' <<endl;

Übereinstimmung mit einem Nicht-Leerzeichen-Zeichen

Das Muster oder die Klasse, die einem Nicht-Leerraumzeichen entspricht, ist [^ f]. Der folgende Code erzeugt eine Übereinstimmung, da das Ziel kein Leerzeichen enthält:

wenn (regex_search('1234abcd',regex('[^TR F] ')))

Kosten<< 'abgestimmt' <<endl;

Der Punkt (.) im Muster

Der Punkt (.) im Muster entspricht jedem Zeichen, einschließlich sich selbst, außer , im Ziel. Eine Übereinstimmung wird im folgenden Code erzeugt:

wenn (regex_search('1234abcd',regex('.')))

Kosten<< 'abgestimmt' <<endl;

Keine übereinstimmenden Ergebnisse im folgenden Code, da das Ziel ist.

wenn (regex_search(' ',regex('.')))

Kosten<< 'abgestimmt' <<endl;

anders

Kosten<< 'nicht passend' <<endl;

Hinweis: Innerhalb einer Zeichenklasse mit eckigen Klammern hat der Punkt keine besondere Bedeutung.

Passende Wiederholungen

Ein Zeichen oder eine Zeichengruppe kann innerhalb des Zielstrings mehrfach vorkommen. Ein Muster kann dieser Wiederholung entsprechen. Die Metazeichen ?, *, + und {} werden verwendet, um die Wiederholung im Ziel abzugleichen. Wenn x ein interessierendes Zeichen in der Zielzeichenfolge ist, haben die Metazeichen die folgenden Bedeutungen:

x*:bedeutet übereinstimmen'x' 0oder öfter,ich.Und.,beliebig oft

x+:bedeutet übereinstimmen'x' 1oder öfter,ich.Und.,wenigstens einmal

x? :bedeutet übereinstimmen'x' 0oder1 Zeit

x{n,}:bedeutet übereinstimmen'x'mindestens n oder öfter.Notizdas Komma.

x{n} :Spiel'x'genau n mal

x{n,m}:Spiel'x'mindestens n mal,aber nicht mehr als m-mal.

Diese Metazeichen heißen Quantoren.

Illustrationen

*

Das * entspricht dem vorangehenden Zeichen oder der vorangehenden Gruppe, null oder mehrmals. o* stimmt mit „o“ im Hund der Zielzeichenfolge überein. Es passt auch oo in Buch und Aussehen. Die Regex, o* entspricht boooo in The animal booooed.. Hinweis: o* entspricht dig, wobei 'o' null (oder mehr) Mal vorkommt.

+

Das + stimmt ein- oder mehrmals mit dem vorangehenden Zeichen oder der vorangehenden Gruppe überein. Vergleichen Sie es mit null oder öfter für *. Die Regex, e+, stimmt also mit „e“ in eat überein, wobei „e“ einmal vorkommt. e+ stimmt auch mit ee bei Schafen überein, wobei „e“ mehr als einmal vorkommt. Hinweis: e+ stimmt nicht mit dig überein, da 'e' in dig nicht mindestens einmal vorkommt.

?

Die ? stimmt mit dem vorhergehenden Zeichen oder der vorhergehenden Gruppe überein, 0 oder 1 Mal (und nicht mehr). Also, e? stimmt mit dig überein, weil 'e' in dig, Nullzeit, auftritt. e? stimmt mit set überein, weil „e“ in set einmal vorkommt. Hinweis: e? passt immer noch zu Schafen; obwohl es bei Schafen zwei „e“ gibt. Hier gibt es eine Nuance – siehe später.

{n,}

Dies entspricht mindestens n aufeinanderfolgenden Wiederholungen eines vorangehenden Zeichens oder einer vorangehenden Gruppe. Die Regex e{2,} stimmt also mit den beiden „e“ im Ziel-Schaf und den drei „e“ im Ziel-Schaf überein. e{2,} stimmt nicht mit set überein, da set nur ein ‚e‘ hat.

{n}

Dies entspricht genau n aufeinanderfolgenden Wiederholungen eines vorangehenden Zeichens oder einer vorangehenden Gruppe. Die Regex, e{2}, stimmt also mit den beiden „e“ im Ziel, Schaf, überein. e{2} stimmt nicht mit set überein, da set nur ein ‚e‘ hat. Nun, e{2} entspricht zwei „e“ im Ziel, Schaf. Hier gibt es eine Nuance – siehe später.

{n, m}

Dies entspricht mehreren aufeinanderfolgenden Wiederholungen eines vorangehenden Zeichens oder einer vorangehenden Gruppe von n bis einschließlich m. e{1,3} stimmt also mit nichts in dig überein, das kein „e“ hat. Es entspricht dem einen „e“ im Set, den beiden „e“ in Schafen, den drei „e“ in Schafen und drei „e“ in Schafen. Beim letzten Spiel gibt es eine Nuance – siehe später.

Passende Alternative

Betrachten Sie die folgende Zielzeichenfolge im Computer.

Der Hof hat Schweine unterschiedlicher Größe.

Der Programmierer möchte vielleicht wissen, ob es sich bei diesem Ziel um eine Ziege, ein Kaninchen oder ein Schwein handelt. Der Code wäre wie folgt:

verkohlenP[] = 'Der Hof hat Schweine unterschiedlicher Größe.';

wenn (regex_search(P,regex('Ziege|Kaninchen|Schwein')))

Kosten<< 'abgestimmt' <<endl;

anders

Kosten<< 'nicht passend' <<endl;

Der Code erzeugt eine Übereinstimmung. Beachten Sie die Verwendung des Wechselzeichens |. Es kann zwei, drei, vier und mehr Optionen geben. C++ wird zuerst versuchen, die erste Alternative, goat, an jeder Zeichenposition in der Zielzeichenfolge zu finden. Gelingt es mit Ziege nicht, versucht es die nächste Alternative, Hase. Gelingt es ihm mit Kaninchen nicht, versucht es die nächste Alternative, Schwein. Wenn Pig fehlschlägt, geht C++ zur nächsten Position im Ziel und beginnt erneut mit der ersten Alternative.

Im obigen Code wird Schwein zugeordnet.

Passender Anfang oder Ende

Anfang


Wenn ^ am Anfang der Regex steht, kann der Anfangstext des Zielstrings mit der Regex übereinstimmen. Im folgenden Code ist der Start des Ziels abc, was abgeglichen wird:

wenn (regex_search('abc und def',regex('^ abc')))

Kosten<< 'abgestimmt' <<endl;

Im folgenden Code findet kein Abgleich statt:

wenn (regex_search('Ja, abc und def',regex('^ abc')))

Kosten<< 'abgestimmt' <<endl;

anders

Kosten<< 'nicht passend' <<endl;

Hier steht abc nicht am Anfang des Ziels.

Hinweis: Das Zirkumflex-Zeichen '^' ist ein Metazeichen am Anfang der Regex, das mit dem Anfang der Zielzeichenfolge übereinstimmt. Es ist immer noch ein Metazeichen am Anfang der Zeichenklasse, wo es die Klasse negiert.

Ende

Wenn $ am Ende der Regex steht, kann der Endtext des Zielstrings mit der Regex übereinstimmen. Im folgenden Code ist das Ende des Ziels xyz, das übereinstimmt:

wenn (regex_search('uvw und xyz',regex('xyz$')))

Kosten<< 'abgestimmt' <<endl;

Im folgenden Code findet kein Abgleich statt:

wenn (regex_search('uvw- und xyz-finale',regex('xyz$')))

Kosten<< 'abgestimmt' <<endl;

anders

Kosten<< 'nicht passend' <<endl;

Hier ist xyz nicht am Ende des Ziels.

Gruppierung

Klammern können verwendet werden, um Zeichen in einem Muster zu gruppieren. Betrachten Sie die folgende Regex:

'ein Konzert (Pianist)'

Die Gruppe hier ist Pianist, umgeben von den Metazeichen ( und ). Es ist eigentlich eine Untergruppe, während ein Konzert (Pianist) die ganze Gruppe ist. Folgendes berücksichtigen:

'Der (Pianist ist gut)'

Hier ist die Untergruppe oder die Untersaite, Pianist ist gut.

Teilsaiten mit gemeinsamen Teilen

Ein Buchhalter ist eine Person, die sich um Bücher kümmert. Stellen Sie sich eine Bibliothek mit Buchhalter und Bücherregal vor. Angenommen, eine der folgenden Zielzeichenfolgen befindet sich im Computer:

'Die Bibliothek hat ein bewundertes Bücherregal.';

'Hier ist der Buchhalter.';

'Der Buchhalter arbeitet mit dem Bücherregal.';

Angenommen, der Programmierer interessiert sich nicht dafür, welcher dieser Sätze im Computer ist. Dennoch ist sein Interesse zu wissen, ob ein Bücherregal oder ein Buchhalter in der Zielzeichenfolge im Computer vorhanden ist. In diesem Fall kann seine Regex sein:

'Bücherregal|Buchhalter.'

Abwechslung nutzen.

Beachten Sie, dass book, das beiden Wörtern gemeinsam ist, in den beiden Wörtern des Musters zweimal getippt wurde. Um zu vermeiden, dass book zweimal eingegeben wird, sollte die Regex besser wie folgt geschrieben werden:

'Buch(Regal|Aufbewahrer)'

Hier die Gruppe, Regal|Bewahrer Das Alternation-Metazeichen wurde noch verwendet, jedoch nicht für zwei lange Wörter. Es wurde für die beiden Endteile der beiden langen Wörter verwendet. C++ behandelt eine Gruppe als Entität. C++ sucht also nach einem Shelf oder Keeper, das direkt nach book kommt. Die Ausgabe des folgenden Codes wird abgeglichen:

verkohlenP[] = 'Die Bibliothek hat ein Bücherregal, das bewundert wird.';

wenn (regex_search(P,regex('Buch(Regal|Aufbewahrer)')))

Kosten<< 'abgestimmt' <<endl;

Bücherregal und nicht Buchhalter wurden abgeglichen.

Die icase- und mehrzeiligen regex_constants

icase

Beim Abgleich wird standardmäßig zwischen Groß- und Kleinschreibung unterschieden. Es kann jedoch die Groß-/Kleinschreibung beachtet werden. Verwenden Sie dazu die regex::icase-Konstante wie im folgenden Code:

wenn (regex_search('Rückmeldung',regex('füttern',regex::icase)))

Kosten<< 'abgestimmt' <<endl;

Die Ausgabe ist angepasst. Feedback mit Großbuchstaben „F“ wurde also mit Feed mit Kleinbuchstaben „f“ abgeglichen. regex::icase wurde zum zweiten Argument des regex()-Konstruktors gemacht. Ohne dies würde die Anweisung keine Übereinstimmung erzeugen.

Mehrzeilig

Betrachten Sie den folgenden Code:

verkohlenP[] = 'Linie 1 Zeile 2 Zeile 3';

wenn (regex_search(P,regex('^. * $')))

Kosten<< 'abgestimmt' <<endl;

anders

Kosten<< 'nicht passend' <<endl;

Die Ausgabe stimmt nicht überein. Die Regex ^.*$ entspricht der Zielzeichenfolge von Anfang bis Ende. .* bedeutet ein beliebiges Zeichen außer , null oder mehrmals. Aufgrund der Zeilenumbruchzeichen ( ) im Ziel gab es keine Übereinstimmung.

Das Ziel ist ein mehrzeiliger String. Damit ‘.’ zum Newline-Zeichen passt, muss die Konstante regex::multiline gebildet werden, das zweite Argument der regex()-Konstruktion. Der folgende Code veranschaulicht dies:

verkohlenP[] = 'Linie 1 Zeile 2 Zeile 3';

wenn (regex_search(P,regex('^. * $',regex::mehrzeilig)))

Kosten<< 'abgestimmt' <<endl;

anders

Kosten<< 'nicht passend' <<endl;

Übereinstimmung mit der gesamten Zielzeichenfolge

Um den gesamten Zielstring abzugleichen, der kein Zeilenumbruchzeichen ( ) enthält, kann die Funktion regex_match() verwendet werden. Diese Funktion unterscheidet sich von regex_search(). Der folgende Code veranschaulicht dies:

verkohlenP[] = 'erster zweiter Dritter';

wenn (regex_match(P,regex('.*Sekunde.*')))

Kosten<< 'abgestimmt' <<endl;

Hier gibt es ein Spiel. Beachten Sie jedoch, dass die Regex mit der gesamten Zielzeichenfolge übereinstimmt und die Zielzeichenfolge kein ' ' enthält.

Das match_results-Objekt

Die Funktion regex_search() kann ein Argument zwischen dem Ziel und dem Regex-Objekt annehmen. Dieses Argument ist das match_results-Objekt. Damit können der gesamte übereinstimmende (Teil-)String und die übereinstimmenden Teil-Strings erkannt werden. Dieses Objekt ist ein spezielles Array mit Methoden. Der Objekttyp match_results ist cmatch (für String-Literale).

Übereinstimmungen erhalten

Betrachten Sie den folgenden Code:

verkohlenP[] = 'Die Frau, die Sie gesucht haben!';

cmatch m;

wenn (regex_search(P,m,regex('w.m.n')))

Kosten<<m[0] <<endl;

Die Zielzeichenfolge hat das Wort Frau. Die Ausgabe ist woman’, was der Regex entspricht, w.m.n. Bei Index null enthält das spezielle Array die einzige Übereinstimmung, nämlich Frau.

Bei Klassenoptionen wird nur der erste im Ziel gefundene Teilstring an das spezielle Array gesendet. Der folgende Code veranschaulicht dies:

cmatch m;

wenn (regex_search('Die Ratte, die Katze, die Fledermaus!',m,regex('[bcr]at')))

Kosten<<m[0] <<endl;

Kosten<<m[1] <<endl;

Kosten<<m[2] <<endl;

Die Ausgabe ist Ratte von Index Null. m[1] und m[2] sind leer.

Bei Alternativen wird nur der erste im Ziel gefundene Teilstring an das spezielle Array gesendet. Der folgende Code veranschaulicht dies:

wenn (regex_search('Das Kaninchen, die Ziege, das Schwein!',m,regex('Ziege|Kaninchen|Schwein')))

Kosten<<m[0] <<endl;

Kosten<<m[1] <<endl;

Kosten<<m[2] <<endl;

Die Ausgabe ist Kaninchen ab Index Null. m[1] und m[2] sind leer.

Gruppierungen

Wenn Gruppen beteiligt sind, geht das vollständige übereinstimmende Muster in die Zelle Null des speziellen Arrays. Die nächste gefundene Teilzeichenfolge geht in Zelle 1; die folgende Teilzeichenfolge geht in Zelle 2; und so weiter. Der folgende Code veranschaulicht dies:

wenn (regex_search('Bester Buchhändler heute!',m,regex('buch ((sel) (ler))')))

Kosten<<m[0] <<endl;

Kosten<<m[1] <<endl;

Kosten<<m[2] <<endl;

Kosten<<m[3] <<endl;

Die Ausgabe ist:

Buchhändler

Verkäufer

Zelle

lesen

Beachten Sie, dass die Gruppe (Verkäufer) vor der Gruppe (sel) steht.

Position des Spiels

Die Position der Übereinstimmung für jede Teilzeichenfolge im cmatch-Array kann bekannt sein. Die Zählung beginnt mit dem ersten Zeichen der Zielzeichenfolge an Position Null. Der folgende Code veranschaulicht dies:

cmatch m;

wenn (regex_search('Bester Buchhändler heute!',m,regex('buch ((sel) (ler))')))

Kosten<<m[0] << '->' <<m.Position(0) <<endl;

Kosten<<m[1] << '->' <<m.Position(1) <<endl;

Kosten<<m[2] << '->' <<m.Position(2) <<endl;

Kosten<<m[3] << '->' <<m.Position(3) <<endl;

Beachten Sie die Verwendung der Positionseigenschaft mit dem Zellindex als Argument. Die Ausgabe ist:

Buchhändler->5

Verkäufer->9

Zelle->9

lesen->12

Suchen und ersetzen

Ein neues Wort oder eine neue Wortgruppe kann die Übereinstimmung ersetzen. Dazu wird die Funktion regex_replace() verwendet. Diesmal ist die Zeichenfolge, in der die Ersetzung erfolgt, jedoch das Zeichenfolgenobjekt und nicht das Zeichenfolgenliteral. Daher muss die String-Bibliothek in das Programm eingebunden werden. Illustration:

#enthalten

#enthalten

#enthalten

mit namespace std;

inthauptsächlich()
{
Saitenstr= »Hier kommt mein Mann. Da geht Ihr Mann.';
Zeichenfolge neuStr=regex_replace(P,regex('Mann'), 'Frau');
Kosten<<neuStr<<endl;

Rückkehr 0;
}

Die hier codierte Funktion regex_replace() ersetzt alle Übereinstimmungen. Das erste Argument der Funktion ist das Ziel, das zweite das Regex-Objekt und das dritte die Ersatzzeichenfolge. Die Funktion gibt einen neuen String zurück, der das Ziel ist, aber den Ersatz hat. Die Ausgabe ist:

Hier kommt meine Frau. Da geht deine Frau.

Abschluss

Der reguläre Ausdruck verwendet Muster, um Teilzeichenfolgen in der Zielsequenzzeichenfolge abzugleichen. Muster haben Metazeichen. Häufig verwendete Funktionen für reguläre Ausdrücke in C++ sind: regex_search(), regex_match() und regex_replace(). Eine Regex ist ein Muster in doppelten Anführungszeichen. Diese Funktionen verwenden jedoch das Regex-Objekt als Argument und nicht nur den Regex. Die Regex muss in ein Regex-Objekt umgewandelt werden, bevor diese Funktionen sie verwenden können.