C++ Academy · Lektion

Performance-Hinweise

Muster sinnvoll kompilieren

Performance-Hinweise ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Kompilieren ist teuer

Das Erstellen eines std::regex aus einer Zeichenkette kompiliert das Muster, was aufwendig ist. Der größte Gewinn besteht darin, es einmal zu kompilieren und wiederzuverwenden.

Vermeiden Sie es, reguläre Ausdrücke innerhalb von Schleifen zu erstellen.
Kompilieren Sie beim Programmstart oder bei der ersten Verwendung.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d+");
    std::string inputs[] = {"12", "ab", "99"};
    for (const auto& s : inputs) {
        std::cout << s << ": " << std::regex_match(s, p) << '\n';
    }
    return 0;
}

Ein kompiliertes Muster wiederverwenden

Erstellen Sie das Muster einmal außerhalb der Schleife und verwenden Sie es für jede Eingabe wieder. Es in jeder Iteration neu aufzubauen, verschwendet Zeit.

#include <iostream>
#include <regex>
#include <vector>

int main() {
    static const std::regex p("[a-z]+");
    std::vector<std::string> words = {"hello", "WORLD", "cpp"};
    int matches = 0;
    for (const auto& w : words) {
        if (std::regex_match(w, p)) ++matches;
    }
    std::cout << "Matched: " << matches << '\n';
    return 0;
}

static const für Konstanten

Für ein unveränderliches Muster deklarieren Sie es innerhalb einer Funktion als static const, damit es über alle Aufrufe hinweg genau einmal kompiliert wird.

#include <iostream>
#include <regex>

bool isEmail(const std::string& s) {
    static const std::regex p("\\w+@\\w+\\.\\w+");
    return std::regex_match(s, p);
}

int main() {
    std::cout << std::boolalpha;
    std::cout << isEmail("a@b.com") << '\n';
    std::cout << isEmail("nope") << '\n';
    return 0;
}

Die richtige Grammatik wählen

Die Regex-Variante (Grammatik) beeinflusst Geschwindigkeit und Funktionsumfang. std::regex::ECMAScript ist die Standardvariante und bietet den größten Funktionsumfang; std::regex::basic oder extended sind einfacher und manchmal schneller.

#include <iostream>
#include <regex>

int main() {
    std::regex p("a+", std::regex::extended);
    std::cout << std::boolalpha << std::regex_match("aaa", p) << '\n';
    return 0;
}

optimize-Flag

Mit std::regex::optimize weisen Sie die Engine an, mehr Zeit in den Aufbau des Musters zu investieren, um schneller abgleichen zu können. Das lohnt sich, wenn Sie sehr viele Abgleiche durchführen.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d{3}-\\d{4}", std::regex::optimize);
    std::cout << std::boolalpha << std::regex_match("123-4567", p) << '\n';
    return 0;
}

Katastrophales Backtracking vermeiden

Verschachtelte Quantifizierer wie (a+)+ können bei bestimmten Eingaben zu exponentieller Laufzeit führen. Bevorzugen Sie einfachere, eindeutig interpretierbare Muster.

#include <iostream>
#include <regex>

int main() {
    std::regex good("a+b");
    std::cout << std::boolalpha << std::regex_match("aaaab", good) << '\n';
    return 0;
}

Nach Möglichkeit Anker verwenden

Durch die Verankerung mit ^ und $ kann die Engine schnell fehlschlagen, statt jede mögliche Startposition auszuprobieren.

#include <iostream>
#include <regex>

int main() {
    std::regex p("^[a-z]{3}$");
    std::cout << std::boolalpha;
    std::cout << std::regex_search("abc", p) << '\n';
    std::cout << std::regex_search("abcd", p) << '\n';
    return 0;
}

Nach Möglichkeit einfache Werkzeuge bevorzugen

Wenn Sie nur nach einer festen Teilzeichenkette suchen müssen, ist std::string::find wesentlich schneller als ein regulärer Ausdruck. Verwenden Sie reguläre Ausdrücke nur für tatsächliche Musterabgleiche.

#include <iostream>
#include <string>

int main() {
    std::string s = "hello world";
    bool has = s.find("world") != std::string::npos;
    std::cout << std::boolalpha << has << '\n';
    return 0;
}

Das Match-Objekt wiederverwenden

Verwenden Sie beim wiederholten Suchen ein einzelnes std::smatch wieder, statt jedes Mal ein neues zu erzeugen, um den Verwaltungsaufwand zu verringern.

#include <iostream>
#include <regex>
#include <vector>

int main() {
    static const std::regex p("(\\d+)");
    std::smatch m;
    std::vector<std::string> data = {"x1", "y22", "z333"};
    for (const auto& s : data) {
        if (std::regex_search(s, m, p)) std::cout << m[1] << ' ';
    }
    std::cout << '\n';
    return 0;
}

Muster eingrenzen

Spezifische Zeichenklassen werden schneller und sicherer gefunden als der allumfassende Punkt. Verwenden Sie [0-9] statt ., wenn Sie Ziffern meinen.

#include <iostream>
#include <regex>

int main() {
    std::regex specific("[0-9]{2}");
    std::cout << std::boolalpha;
    std::cout << std::regex_match("42", specific) << '\n';
    std::cout << std::regex_match("ab", specific) << '\n';
    return 0;
}

Vor der Optimierung messen

Wenden Sie Ihr Wissen über <chrono> an: Messen Sie die Ausführungszeit der regulären Ausdrücke, um zu bestätigen, dass eine Änderung tatsächlich hilft, bevor Sie sie übernehmen.

#include <iostream>
#include <regex>
#include <chrono>

int main() {
    using namespace std::chrono;
    static const std::regex p("\\d+");
    auto s = steady_clock::now();
    int hits = 0;
    for (int i = 0; i < 1000; ++i) {
        if (std::regex_search(std::string("x") + std::to_string(i), p)) ++hits;
    }
    auto e = steady_clock::now();
    std::cout << "hits=" << hits << ", timed: " << ((e - s).count() >= 0) << '\n';
    return 0;
}

Schnelltest

Testen Sie Ihr Verständnis der Leistung regulärer Ausdrücke.

Zusammenfassung

Sie haben gelernt, reguläre Ausdrücke effizient zu verwenden:

Muster einmal kompilieren, idealerweise als static const, und wiederverwenden
die passende Grammatik auswählen und optimize in Betracht ziehen
katastrophales Backtracking vermeiden und nach Möglichkeit Anker verwenden
für feste Teilzeichenfolgen einfachere Werkzeuge wie find verwenden und Änderungen messen

Damit ist der Kurs zu regulären Ausdrücken abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Performance-Hinweise“ kostenlos?

Ja — der vollständige Text von „Performance-Hinweise“ 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 „Performance-Hinweise“?

Muster sinnvoll kompilieren 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 4 von 4.

Wie lange dauert die Lektion „Performance-Hinweise“?

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