C++ Academy · Lektion

Erfassungsgruppen

Abgeglichene Teile extrahieren

Erfassungsgruppen ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine Capturing-Gruppe?

Klammern in einem Muster erzeugen eine Capturing-Gruppe. Sie merken sich den Teil des Textes, dem sie entsprochen haben, sodass Sie ihn anschließend extrahieren können.

(\\d+) erfasst eine Folge von Ziffern.
Die Ergebnisse werden in einem std::smatch abgelegt.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d+)");
    std::smatch m;
    std::string s = "order 42";
    if (std::regex_search(s, m, p)) {
        std::cout << "Captured: " << m[1] << '\n';
    }
    return 0;
}

Das smatch-Ergebnis

std::smatch speichert die Ergebnisse des Abgleichs. Der Index [0] steht für die gesamte Übereinstimmung, [1], [2], ... für die Capturing-Gruppen in ihrer Reihenfolge.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\w+)@(\\w+)");
    std::smatch m;
    std::string s = "user@host";
    if (std::regex_search(s, m, p)) {
        std::cout << "Whole: " << m[0] << '\n';
        std::cout << "User: " << m[1] << ", Host: " << m[2] << '\n';
    }
    return 0;
}

Mehrere Gruppen

Sie können mehrere Bestandteile gleichzeitig erfassen, zum Beispiel ein Datum in Jahr, Monat und Tag aufteilen.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d{4})-(\\d{2})-(\\d{2})");
    std::smatch m;
    std::string s = "2026-05-30";
    if (std::regex_match(s, m, p)) {
        std::cout << "Y=" << m[1] << " M=" << m[2] << " D=" << m[3] << '\n';
    }
    return 0;
}

str(), position(), length()

Jede Gruppe bietet str() für ihren Text, position() für ihren Offset und length() für ihre Länge innerhalb der Eingabe.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d+)");
    std::smatch m;
    std::string s = "abc 789 xyz";
    if (std::regex_search(s, m, p)) {
        std::cout << "str: " << m[1].str() << '\n';
        std::cout << "pos: " << m.position(1) << '\n';
        std::cout << "len: " << m.length(1) << '\n';
    }
    return 0;
}

Präfix und Suffix

Das Match-Objekt stellt außerdem prefix() (Text vor der Übereinstimmung) und suffix() (Text danach) bereit.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d+");
    std::smatch m;
    std::string s = "left 55 right";
    if (std::regex_search(s, m, p)) {
        std::cout << "prefix: [" << m.prefix() << "]\n";
        std::cout << "suffix: [" << m.suffix() << "]\n";
    }
    return 0;
}

Nicht erfassende Gruppen

Verwenden Sie (?:...), um zu gruppieren, ohne etwas zu erfassen. Dadurch bleiben Ihre nummerierten Gruppen aussagekräftig, wenn Sie die Gruppierung nur für Quantifizierer oder Alternativen benötigen.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(?:Mr|Ms) (\\w+)");
    std::smatch m;
    std::string s = "Ms Smith";
    if (std::regex_search(s, m, p)) {
        std::cout << "Name: " << m[1] << '\n';
    }
    return 0;
}

Prüfen, ob eine Gruppe übereinstimmt

Eine optionale Gruppe nimmt möglicherweise nicht an einer Übereinstimmung teil. Prüfen Sie matched am Submatch, um festzustellen, ob etwas erfasst wurde.

#include <iostream>
#include <regex>

int main() {
    std::regex p("file(\\.txt)?");
    std::smatch m;
    std::string s = "file";
    if (std::regex_match(s, m, p)) {
        std::cout << std::boolalpha << "ext matched: " << m[1].matched << '\n';
    }
    return 0;
}

Alle Übereinstimmungen durchlaufen

std::sregex_iterator durchläuft jede Übereinstimmung in einer Zeichenkette und liefert dabei auch die einzelnen Gruppen.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d+)");
    std::string s = "a1 b22 c333";
    auto begin = std::sregex_iterator(s.begin(), s.end(), p);
    auto end = std::sregex_iterator();
    for (auto it = begin; it != end; ++it) {
        std::cout << (*it)[1] << '\n';
    }
    return 0;
}

Übereinstimmungen zählen

Kombinieren Sie den Iterator mit std::distance, um zu zählen, wie oft ein Muster vorkommt.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d+");
    std::string s = "1 22 333 4444";
    auto begin = std::sregex_iterator(s.begin(), s.end(), p);
    auto end = std::sregex_iterator();
    std::cout << "Count: " << std::distance(begin, end) << '\n';
    return 0;
}

Schlüssel-Wert-Paare extrahieren

Mit zwei Gruppen pro Übereinstimmung können Sie einfachen strukturierten Text analysieren, etwa Token im Format key=value.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\w+)=(\\w+)");
    std::string s = "a=1 b=2 c=3";
    auto begin = std::sregex_iterator(s.begin(), s.end(), p);
    auto end = std::sregex_iterator();
    for (auto it = begin; it != end; ++it) {
        std::cout << (*it)[1] << " -> " << (*it)[2] << '\n';
    }
    return 0;
}

Erfassungen speichern

Kopieren Sie ein erfasstes Submatch mit str() in einen std::string, damit die Daten gültig bleiben, nachdem das Match-Objekt nicht mehr existiert.

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::regex p("v(\\d+)");
    std::smatch m;
    std::string s = "version v7";
    std::string version;
    if (std::regex_search(s, m, p)) {
        version = m[1].str();
    }
    std::cout << "Stored: " << version << '\n';
    return 0;
}

Kurzer Check

Prüfen Sie Ihr Verständnis der Indizierung von Capturing-Gruppen.

Zusammenfassung

Sie haben gelernt, wie Sie mit Capturing-Gruppen Daten extrahieren:

Klammern erfassen; (?:...) gruppiert, ohne etwas zu erfassen
smatch[0] ist die gesamte Übereinstimmung, [1]+ sind die Gruppen
str(), position(), length(), prefix(), suffix()
sregex_iterator durchläuft jede Übereinstimmung

Als Nächstes transformieren Sie Text mithilfe von Suchen und Ersetzen.

Häufig gestellte Fragen

Ist die Lektion „Erfassungsgruppen“ kostenlos?

Ja — der vollständige Text von „Erfassungsgruppen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Erfassungsgruppen“?

Abgeglichene Teile extrahieren Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Erfassungsgruppen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy