Grundlagen der regulären Ausdrucksbasis in C ++

Betrachten Sie den folgenden Satz in Zitaten: "Hier ist mein Mann."

Diese Zeichenfolge kann sich im Computer befinden, und der Benutzer möchte möglicherweise wissen, ob er das Wort "Mann" hat. Wenn es das Wort Mann hat, möchte er vielleicht das Wort „Mann“ in „Frau“ ändern; so dass die Zeichenfolge lesen sollte:

"Hier ist meine Frau."

Es gibt viele andere Wünsche wie diese vom Computerbenutzer. Einige sind komplex. Regelmäßiger Ausdruck, abgekürzt, Regex, ist Gegenstand der Behandlung dieser Probleme durch den Computer. C ++ wird mit einer Bibliothek namens Regex geliefert. Ein C ++ - Programm zur Behandlung von Regex sollte also mit:

#enthalten
#enthalten
Verwenden von Namespace STD;

Dieser Artikel erklärt die Grundlagen der regelmäßigen Expression in C++.

Artikelinhalt

• Regelmäßige Ausdrucksgrundlagen
• Muster
• Charakterklassen
• Passende Weißespace
• Die Periode (.) im Muster
• Passende Wiederholungen
• Passende Abwechslung
• Matching Anfang oder Ende
• Gruppierung
• Die ICAS- und Multiline Regex_Constants
• Das gesamte Ziel entsprechen
• Das Match_Results -Objekt
• Spielposition
• Suchen und ersetzen
• Abschluss

Regelmäßige Ausdrucksgrundlagen

Regex

Eine Schnur wie „Hier ist mein Mann.Oben ist die Zielsequenz oder die Zielzeichenfolge oder einfach das Ziel. "Mann", der gesucht wurde, ist der reguläre Ausdruck oder einfach Regex.

Matching

Die Übereinstimmung soll auftreten, wenn das Wort oder die Suchphrase gefunden wird. Nach dem Matching kann ein Ersatz stattfinden. Zum Beispiel kann es nach „Mann“ oben gefunden werden, kann es durch „Frau“ ersetzt werden.

Einfacher Matching

Das folgende Programm zeigt, wie das Wort „Mann“ übereinstimmt.

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Regex Reg ("Mann");
if (regex_search ("Hier ist mein Mann.", Reg))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;
Rückkehr 0;

Die Funktion regex_search () gibt true zurück, wenn ein Übereinstimmung vorliegt und falsch zurückgibt, wenn keine Übereinstimmung auftritt. Hier nimmt die Funktion zwei Argumente an: Die erste ist die Zielzeichenfolge, und die zweite ist das Regex -Objekt. Der Regex selbst ist "Mann", in doppelten Quoten. Die erste Anweisung in der Funktion main () bildet das Regex -Objekt. Regex ist ein Typ und Reg ist das Regex -Objekt. Die Ausgabe des oben genannten Programms ist "Matched", wie in der Zielzeichenfolge "Mann" zu sehen ist. Wenn "Mann" im Ziel nicht gesehen worden wäre, hätte regex_search () falsch zurückgegeben, und die Ausgabe wäre "nicht übereinstimmen" gewesen.

Die Ausgabe des folgenden Codes ist „nicht übereinstimmen“:

Regex Reg ("Mann");
if (regex_search ("Hier ist meine Herstellung.", Reg))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;

Nicht übereinstimmt, weil der Regex -Mann nicht in der gesamten Zielzeichenfolge gefunden werden konnte ", hier ist meine Herstellung."

Muster

Der reguläre Ausdruck „Mann“ oben ist sehr einfach. Regexes sind normalerweise nicht so einfach. Regelmäßige Ausdrücke haben Metacharacoders. Metacharacter sind Charaktere mit besonderen Bedeutungen. Ein Metacharacter ist ein Charakter über Charaktere. C ++ Regex Metacharacter sind:

^ $ \ . * + ? () [] |

Ein Regex mit oder ohne Metacharacter ist ein Muster.

Charakterklassen

Eckige Klammern

Ein Muster kann Zeichen in quadratischen Klammern haben. Damit würde eine bestimmte Position in der Zielzeichenfolge einen der Charaktere der Quadratklammern übereinstimmen. Betrachten Sie die folgenden Ziele:

"Die Katze ist im Raum."
"Die Fledermaus ist im Raum."
"Die Ratte ist im Raum."

Der Regex [CBR] bei würde CAT im ersten Ziel übereinstimmen. Es würde Fledermaus im zweiten Ziel entsprechen. Es würde mit Ratten im dritten Ziel übereinstimmen. Dies liegt daran. Das folgende Codesegment zeigt dies:

regex reg ("[cbr] at");
if (regex_search ("Die Katze ist im Raum.", Reg))
Cout << "matched" << endl;
if (regex_search ("Die Fledermaus befindet sich im Raum.", Reg))
Cout << "matched" << endl;
if (regex_search ("Die Ratte ist im Raum.", Reg))
Cout << "matched" << endl;

Die Ausgabe ist:

angepasst
angepasst
angepasst

Charaktere

Die Klasse [CBR] im Muster [CBR] würde mehrere mögliche Zeichen im Ziel übereinstimmen. Es würde mit 'C' oder 'B' oder 'R' im Ziel übereinstimmen. Wenn das Ziel keine von 'C' oder 'B' oder 'R' hat, gefolgt von „AT“, würde es kein Übereinstimmung geben.

Einige Möglichkeiten wie 'C' oder 'B' oder 'R' existieren in einem Bereich. Der Ziffernbereich von 0 bis 9 hat 10 Möglichkeiten, und das Muster dafür ist [0-9]. Der Bereich der Kleinbuchstaben-Alphabete, A bis Z, hat 26 Möglichkeiten, und das Muster dafür ist [a-z]. Der Bereich der Großbuchstaben, A bis Z, hat 26 Möglichkeiten, und das Muster dafür ist [a-z]. - ist offiziell kein Metacharakter, aber in quadratischen Klammern würde es eine Reichweite anzeigen. Das Folgende erzeugt also ein Match:

if (regex_search ("id6id", regex ("[0-9]")))
Cout << "matched" << endl;

Beachten Sie, wie der Regex als zweites Argument konstruiert wurde. Die Übereinstimmung tritt zwischen der Ziffer, 6 im Bereich von 0 bis 9 und 6 im Ziel „ID6ID“ auf. Der obige Code entspricht:

if (regex_search ("id6id", regex ("[0123456789]")))
Cout << "matched" << endl;

Der folgende Code erzeugt eine Übereinstimmung:

char str [] = "id6ie";
if (regex_search (str, regex ("[a-z]")))
Cout << "matched" << endl;

Beachten Sie, dass das erste Argument hier eine String -Variable ist und nicht die String -Literal. Das Match ist zwischen 'I' in [a-z] und 'i' in "id6ie".

Vergessen Sie nicht, dass eine Reichweite eine Klasse ist. Rechts am Bereich oder links neben dem Bereich des Musters kann es Text geben. Der folgende Code erzeugt eine Übereinstimmung:

if (regex_search ("ID2IDPOST-95222 -__ DDELINK__294_3116034780"> ist eine ID ", Regex (" ID [0-9] ID ")))
Cout << "matched" << endl;

Die Übereinstimmung ist zwischen "ID [0-9] ID" und "ID2ID". Der Rest der Zielzeichenfolge, "ist eine ID", ist in dieser Situation nicht übereinstimmt.

Wie im regulären Expression -Subjekt (Regexes) verwendet, bedeutet die Wortklasse tatsächlich einen Satz. Das heißt, einer der Zeichen im Set ist mithalten.

HINWEIS: Der Bindestrich - ist nur in quadratischen Klammern ein Metacharakter, der einen Bereich anzeigt. Es ist kein Metacharakter in der Regex außerhalb der Quadratklammern.

Negation

Eine Klasse mit einem Bereich kann negiert werden. Das heißt, nicht der Zeichen im Set (Klasse) sollten übereinstimmen. Dies ist mit dem Metacharacter zu Beginn des Klassenmuster. [^0-9] bedeutet also, dass das Zeichen an der entsprechenden Position im Ziel angepasst wird, was kein Zeichen im Bereich von 0 bis 9 inklusive ist. Der folgende Code erzeugt also keine Übereinstimmung:

if (regex_search ("012345678910112", regex ("[^0-9]")))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;

Eine Ziffer innerhalb des Bereichs von 0 bis 9 konnte in einer der Zielzeichenfolge "0123456789101112" gefunden werden; Es gibt also keine Übereinstimmung - Negation.

Der folgende Code erzeugt eine Übereinstimmung:

if (regex_search ("abcdefghij", regex ("[^0-9]")))
Cout << "matched" << endl;

Es konnte keine Ziffer im Ziel „Abcdefghij“ gefunden werden; Es gibt also ein Match.

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

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

Andere Negationen existieren.

Passende Weißespace

"oder \ t oder \ r oder \ n oder \ f ist ein Whitespace -Zeichen. Im folgenden Code stimmt der Regex, „\ n“, '\ n' im Ziel überein:

if (regex_search ("von Zeile 1.\ r \ nof Zeile zwei.", regex (" \ n ")))
Cout << "matched" << endl;

Übereinstimmung mit einem Whitespace -Charakter

Das Muster oder die Klasse, die zu einem beliebigen White -Space -Zeichen entspricht, ist [\ t \ r \ n \ f]. Im folgenden Code ist "übereinstimmt:

if (regex_search ("eins zwei", regex ("[\ t \ r \ n \ f]"))))
Cout << "matched" << endl;

Übereinstimmung mit einem Nicht-Whitespace-Charakter

Das Muster oder die Klasse, die zu einem nicht weißen Raumzeichen entspricht, ist [^ \ t \ r \ n \ f]. Der folgende Code erzeugt eine Übereinstimmung, da das Ziel kein Weißespace enthält:

if (regex_search ("1234abcd", regex ("[^ \ t \ r \ n \ f]"))))
Cout << "matched" << endl;

Die Periode (.) im Muster

Die Periode (.) im Muster entspricht jedem Zeichen, einschließlich sich selbst, außer \ n, im Ziel. Im folgenden Code wird ein Match erstellt:

if (regex_search ("1234abcd", regex (".")))
Cout << "matched" << endl;

Keine Übereinstimmungsergebnisse im folgenden Code, da das Ziel "\ n" ist.

if (regex_search ("\ n", regex (".")))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;

Hinweis: In einer Charakterklasse mit quadratischen Klammern hat die Periode keine besondere Bedeutung.

Passende Wiederholungen

Ein Zeichen oder eine Gruppe von Zeichen kann innerhalb der Zielzeichenfolge mehr als einmal auftreten. Ein Muster kann mit dieser Wiederholung übereinstimmen. Die Metacharacter, ?, *, +und werden verwendet, um die Wiederholung im Ziel zu entsprechen. Wenn x ein Zeichen von Interesse an der Zielzeichenfolge ist, haben die Metacharacter die folgenden Bedeutungen:

x*: bedeutet Match 'x' 0 oder mehrmals, ich.e., beliebig viele Male
x+: bedeutet übereinstimmen 'x' 1 oder mehrmals, ich.e., mindestens einmal
X? : bedeutet Match 'x' 0 oder 1 mal Match
x n,: Means Match 'x' mindestens n oder mehrmals. Beachten Sie das Komma.
X n: Übereinstimmung 'x' genau n -mal n -mal
x n, m: mindestens n -mal 'x' übereinstimmen, aber nicht mehr als m -mal.

Diese Metacharacter werden als Quantifizierer bezeichnet.

Illustrationen

*

Der * entspricht dem vorhergehenden Charakter oder der vorhergehenden Gruppe, Null oder mehrmals. "O*" passt zu 'O' in "Hund" der Zielstring. Es passt auch zu „OO“ in „Buch“ und „Looking“. Der Regex, "O*" entspricht "Boooo" in "The Animal Boooed".”. HINWEIS: "O*" stimmt mit "Dig" überein, wo 'O' null (oder mehr) Zeit auftritt.

+

Der + entspricht dem vorhergehenden Charakter oder der vorhergehenden Gruppe, 1 oder mehrmals. Vergleichen Sie es mit Null oder mehrmals für *. Also entspricht der Regex, „E+“ 'e' in „Eat“, wo 'e' einmal vorkommt. "E+" stimmt auch mit "ee" in "Sheep" überein, wo 'e' mehr als einmal vorkommt. Hinweis: "E+" stimmt nicht mit "Dig" überein, da in "Dig" 'E' nicht mindestens einmal auftritt.

?

Der ? entspricht dem vorhergehenden Charakter oder dem vorhergehenden Gruppen, 0 oder 1 Zeit (und nicht mehr). Also, „e?"Übereinstimmt" Dig ", weil 'e' in" Dig ", Nullzeit, vorkommt. „E?"Übereinstimmung" set ", weil 'e' einmal in" Set ", einmal vorhanden. Hinweis: „E?"Passt immer noch" Schafe "; Obwohl es zwei 'E in "Schaf" gibt. Hier gibt es eine Nuance - siehe später.

N,

Dies entspricht mindestens n aufeinanderfolgende Wiederholungen eines vorhergehenden Charakters oder einer vorhergehenden Gruppe. Also entspricht der Regex, "E 2," den beiden "E" im Ziel, "Schaf" und die drei "E" im Ziel "Sheeep". "E 2," stimmt nicht mit "set" überein, weil "set" nur ein 'e' hat.

N

Dies entspricht genau n aufeinanderfolgenden Wiederholungen eines vorhergehenden Charakters oder einer vorhergehenden Gruppe. Also entspricht der Regex, "E 2" mit den beiden "E's im Ziel", "Schafe". "E 2" stimmt nicht mit "set" überein, weil "set" nur ein 'e' hat ". Nun, "e 2" entspricht zwei "E's im Ziel" Sheeep ". Hier gibt es eine Nuance - siehe später.

n, m

Dies entspricht mehreren aufeinanderfolgenden Wiederholungen eines vorhergehenden Charakters oder einer vorhergehenden Gruppe, überall von n bis m, einschließlich. "E 1,3" entspricht also nichts in "Dig", was kein "e" hat. Es entspricht dem "E" in "Set", den beiden "E's in" Sheep ", den drei" in "Sheeep" und drei "E in" Sheeeep ". Es gibt eine Nuance beim letzten Spiel - später siehe.

Passende Abwechslung

Betrachten Sie die folgende Zielzeichenfolge im Computer.

„Die Farm hat Schweine unterschiedlicher Größen.”

Der Programmierer möchte vielleicht wissen, ob dieses Ziel "Ziege" oder "Kaninchen" oder "Schwein" hat. Der Code wäre wie folgt:

char str [] = "Die Farm hat Schweine unterschiedlicher Größen.";
if (regex_search (str, regex ("Ziege | Kaninchen | Schwein")))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;

Der Code erzeugt eine Übereinstimmung. Beachten Sie die Verwendung des Wechselzeichens, |. Es können zwei, drei, vier und weitere Optionen sein. C ++ wird zunächst versuchen, die erste Alternative, "Ziege", an jeder Zeichenposition in der Zielzeichenfolge zu erreichen. Wenn es nicht mit "Ziege" gelingt, versucht es die nächste Alternative, "Kaninchen". Wenn es nicht mit „Kaninchen“ erfolgreich ist, versucht es die nächste Alternative, „Schwein“. Wenn „Schwein“ fehlschlägt, wechselt C ++ zur nächsten Position im Ziel und beginnt erneut mit der ersten Alternative.

Im obigen Code wird „Schwein“ übereinstimmt.

Matching Anfang oder Ende

Anfang

Wenn ^ am Anfang des Regex liegt, kann der Anfangstext der Zielzeichenfolge von der Regex übereinstimmen. Im folgenden Code ist der Beginn des Ziels „ABC“, was übereinstimmt:

if (regex_search ("abc und def", regex ("^abc")))
Cout << "matched" << endl;

Im folgenden Code findet keine Übereinstimmung statt:

if (regex_search ("Ja, ABC und Def", regex ("^abc")))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;

Hier steht „ABC“ nicht am Anfang des Ziels.

HINWEIS: Das Circumflex -Zeichen '^' ist ein Metacharakter zu Beginn des Regex, der dem Beginn der Zielzeichenfolge entspricht. Es ist immer noch ein Metacharakter zu Beginn der Charakterklasse, wo es die Klasse negiert.

Ende

Wenn sich $ am Ende des Regex befindet, kann der Endtext der Zielzeichenfolge vom Regex übereinstimmen. Im folgenden Code ist das Ende des Ziels "XYZ", was übereinstimmt:

if (regex_search ("uvw und xyz", regex ("xyz $")))
Cout << "matched" << endl;

Im folgenden Code findet keine Übereinstimmung statt:

if (regex_search ("uvw und xyz final", regex ("xyz $")))
Cout << "matched" << endl;
anders
Cout << "not matched" << 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 Metacharactern (und). Es ist eigentlich eine Untergruppe, während „ein Konzert (Pianist)“ die ganze Gruppe ist. Folgendes berücksichtigen:

"Der (Pianist ist gut)" "

Hier lautet die Untergruppe oder die Unterstriche „Pianist ist gut“.

Unterstrahlen 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, einer der folgenden Zielzeichenfolgen ist im Computer:

"Die Bibliothek hat ein Bücherregal, das bewundert wird.";
"Hier ist der Buchhalter.";
"Der Buchhalter arbeitet mit dem Bücherregal.";

Angenommen, das Interesse des Programmierers besteht nicht darin, zu wissen, welcher dieser Sätze im Computer ist. Dennoch ist es sein Interesse zu wissen, ob „Bücherregal“ oder „Buchhalter“ in der Zielzeichenfolge im Computer vorhanden ist. In diesem Fall kann seine Regex:

"Bücherregal | Buchhalter."

Verwenden von Wechsel.

Beachten Sie, dass „Buch“, das bei beiden Wörtern gemeinsam ist, in den beiden Wörtern im Muster zweimal tippt wurde. Um das Tippen von „Buch“ zweimal zu vermeiden, wäre der Regex besser geschrieben als:

"Buch (Regal | Keeper)"

Hier wurde die Gruppe „Shelf | Keeper“ der Wechsel Metacharacter verwendet, aber nicht für zwei lange Wörter. Es wurde für die beiden endenden Teile der beiden langen Wörter verwendet. C ++ behandelt eine Gruppe als Entität. C ++ sucht also nach "Regal" oder "Keeper", der unmittelbar nach "Buch" kommt. Die Ausgabe des folgenden Codes ist „übereinstimmen“:

char st [] = "Die Bibliothek hat ein Bücherregal, das bewundert wird.";
if (regex_search (str, regex ("Buch (Regal | Keeper)")))
Cout << "matched" << endl;

"Bücherregal" und nicht "Buchhalter" wurden abgestimmt.

Die ICAS- und Multiline Regex_Constants

ICASE

Die Übereinstimmung ist standardmäßig fallsempfindlich. Es kann jedoch unempfindlich zu Fall gemacht werden. Um dies zu erreichen, verwenden Sie die Regex :: ICASE -Konstante wie im folgenden Code:

if (regex_search ("Feedback", regex ("feed", regex :: icase))))
Cout << "matched" << endl;

Die Ausgabe ist "übereinstimmen". "Feedback" mit Großbuchstaben 'F' wurde also durch "Feed" mit Kleinbuchstaben 'F' übereinstimmen. "Regex :: icase" wurde zum zweiten Argument des Regex () -Konstruktors. Ohne das würde die Aussage kein Match erzeugen.

Multiline

Betrachten Sie den folgenden Code:

char str [] = "Zeile 1 \ nline 2 \ nline 3";
if (regex_search (str, regex ("^.*$ ")))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;

Die Ausgabe ist "nicht übereinstimmen". Der Regex, “^.*$ “, Entspricht der Zielzeichenfolge von Anfang bis Ende. “.*”Bedeutet ein Zeichen außer \ n, Null oder mehrmals. Aufgrund der Newline -Zeichen (\ n) im Ziel gab es also keine Übereinstimmung.

Das Ziel ist eine Multiline -Zeichenfolge. Damit '.Um dem neuen Charakter zu entsprechen, muss die konstante „Regex :: Multiline“ vorgenommen werden, das zweite Argument der Regex () -Baustunde. Der folgende Code zeigt dies:

char str [] = "Zeile 1 \ nline 2 \ nline 3";
if (regex_search (str, regex ("^.*$ ", regex :: Multiline))))
Cout << "matched" << endl;
anders
Cout << "not matched" << endl;

Übereinstimmung der gesamten Zielzeichenfolge

Um die gesamte Zielzeichenfolge zu entsprechen, die nicht über das neue Zeilenzeichen (\ n) verfügt, kann die Funktion regex_match () verwendet werden. Diese Funktion unterscheidet sich von regex_search (). Der folgende Code zeigt dies:

char str [] = "Erstes drittes Drittel";
if (regex_match (str, regex (".*zweite.*")))
Cout << "matched" << endl;

Hier gibt es ein Match. Beachten Sie jedoch, dass der Regex mit der gesamten Zielzeichenfolge übereinstimmt und die Zielzeichenfolge keine '\ n' hat.

Das Match_Results -Objekt

Die Funktion regex_search () kann ein Argument zwischen dem Ziel und dem Regex-Objekt aufnehmen. Dieses Argument ist das Objekt match_results. Die gesamte übereinstimmende (Teil-) Zeichenfolge und die übereinstimmenden Unterstriche können damit bekannt sein. Dieses Objekt ist ein spezielles Array mit Methoden. Der Objekttyp von Match_Results ist CMatch (für String -Literale).

Übereinstimmungen erhalten

Betrachten Sie den folgenden Code:

Char st [] = "Die Frau, nach der Sie gesucht haben!";
CMatch M;
if (regex_search (str, m, regex ("w.M.N")))
Cout << m[0] << endl;

Die Zielzeichenfolge hat das Wort "Frau". Die Ausgabe ist „Frau“, die dem Regex entspricht, „W.M.N". Bei Index Null hält das Special Array das einzige Match, nämlich „Frau“.

Mit Klassenoptionen wird nur die erste im Ziel gefundene Unterstriche an das Special Array gesendet. Der folgende Code zeigt dies:

CMatch M;
if (regex_search ("die Ratte, die Katze, die Fledermaus!", m, regex (" [bcr] at "))))
Cout << m[0] << endl;
Cout << m[1] << endl;
Cout << m[2] << endl;

Der Ausgang ist „Ratte“ aus Index Null. M [1] und M [2] sind leer.

Mit Alternativen wird nur die erste im Ziel gefundene Unterstriche an das Special Array gesendet. Der folgende Code zeigt dies:

if (regex_search ("Das Kaninchen, die Ziege, das Schwein!", m, regex (" Ziege | Kaninchen | Schwein ")))
Cout << m[0] << endl;
Cout << m[1] << endl;
Cout << m[2] << endl;

Die Ausgabe ist "Kaninchen" aus Index Null. M [1] und M [2] sind leer.

Gruppierungen

Wenn Gruppen involviert sind, wird das vollständige Muster in die Zelle Null des Spezialarrays gelangt. Die nächste gefundene Unterliege geht in Zelle 1; Die Unterliege folgt in Zelle 2; usw. Der folgende Code zeigt dies:

if (regex_search ("Bester Buchhändler heute!", m, regex (" Buch ((sel) (ler)) ")))
Cout << m[0] << endl;
Cout << m[1] << endl;
Cout << m[2] << endl;
Cout << m[3] << endl;

Die Ausgabe ist:

Buchhändler
Verkäufer
Sel
ler

Beachten Sie, dass die Gruppe (Verkäufer) vor der Gruppe (SEL) kommt.

Spielposition

Die Übereinstimmungsposition für jede Unterstring im CMatch-Array kann bekannt sein. Das Zählen beginnt vom ersten Zeichen der Zielzeichenfolge an Position Null. Der folgende Code zeigt dies:

CMatch M;
if (regex_search ("Bester Buchhändler heute!", m, regex (" Buch ((sel) (ler)) ")))
Cout << m[0] << "->" << m.position(0) << endl;
Cout << m[1] << "->" << m.position(1) << endl;
Cout << m[2] << "->" << m.position(2) << endl;
Cout << 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
Sel-> 9
ler-> 12

Suchen und ersetzen

Ein neues Wort oder eine neue Phrase kann die Übereinstimmung ersetzen. Die Funktion regex_replace () wird dafür verwendet. Diesmal ist jedoch die Zeichenfolge, in der der Ersatz auftritt. Die String -Bibliothek muss also in das Programm aufgenommen werden. Illustration:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

String str = "Hier kommt mein Mann. Da geht dein Mann.";
String NewStr = regex_replace (str, regex ("Mann"), "Frau");
Cout << newStr << endl;
Rückkehr 0;

Die hier codierte Regex_Replace () -Funktion ersetzt alle Übereinstimmungen. Das erste Argument der Funktion ist das Ziel, das zweite ist das Regex -Objekt und das dritte die Ersatzzeichenfolge. Die Funktion gibt eine neue Zeichenfolge zurück, die 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 Substrings in der Zielsequenzzeichenfolge zu übereinstimmen. Muster haben Metacharacter. Häufig verwendete Funktionen für C ++ - reguläre Ausdrücke sind: regex_search (), regex_match () und regex_replace (). Ein Regex ist ein Muster in Doppelquoten. Diese Funktionen nehmen das Regex -Objekt jedoch als Argument und nicht nur als Regex an. Der Regex muss in ein Regex -Objekt gemacht werden, bevor diese Funktionen es verwenden können.