C++ Academy · Les

Opmerkingen over prestaties

Compileer patronen verstandig

Les 4 van 413 stappen

Opmerkingen over prestaties is een gratis C++ Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Compileren is duur

Het maken van een std::regex vanuit een tekenreeks compileert het patroon, wat duur is. De grootste winst behaal je door één keer te compileren en het resultaat opnieuw te gebruiken.

Vermijd het maken van regex binnen lussen.
Compileer bij het opstarten of bij het eerste gebruik.

#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;
}

Een gecompileerd patroon hergebruiken

Maak het patroon één keer buiten de lus en gebruik het voor elke invoer opnieuw. Het bij elke iteratie opnieuw opbouwen verspilt tijd.

#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 voor constanten

Declareer een patroon dat nooit verandert als static const binnen een functie, zodat het over alle aanroepen heen precies één keer wordt gecompileerd.

#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;
}

De juiste grammatica kiezen

De regexvariant (grammatica) beïnvloedt snelheid en functies. std::regex::ECMAScript is de standaard en meest uitgebreide variant; std::regex::basic of extended zijn eenvoudiger en soms sneller.

#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-vlag

Door std::regex::optimize toe te voegen, geef je de engine opdracht meer tijd te besteden aan het opbouwen van het patroon in ruil voor sneller vergelijken. Dat loont wanneer je veel overeenkomsten zoekt.

#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;
}

Catastrofaal terugzoeken vermijden

Geneste kwantoren zoals (a+)+ kunnen bij bepaalde invoer leiden tot een exponentieel groeiende uitvoeringstijd. Geef de voorkeur aan eenvoudigere, ondubbelzinnige patronen.

#include <iostream>
#include <regex>

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

Veranker waar mogelijk

Door te verankeren met ^ en $ kan de engine snel stoppen wanneer er geen overeenkomst is, in plaats van elke startpositie te proberen.

#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;
}

Geef waar mogelijk de voorkeur aan eenvoudige hulpmiddelen

Als je alleen op een vaste deeltekenreeks hoeft te controleren, is std::string::find veel sneller dan een regex. Gebruik regex alleen voor echte patroonvergelijking.

#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;
}

Het overeenkomstobject hergebruiken

Gebruik bij herhaald zoeken één std::smatch opnieuw in plaats van telkens een nieuw object toe te wijzen, om de overhead te beperken.

#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;
}

Verfijn je patroon

Specifieke tekenklassen herkennen sneller en veiliger dan de allesvangende punt. Geef de voorkeur aan [0-9] boven . als je cijfers bedoelt.

#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;
}

Meten voordat je optimaliseert

Pas toe wat je over <chrono> hebt geleerd: meet hoelang je reguliere expressie wordt uitgevoerd om te bevestigen dat een wijziging echt helpt voordat je die doorvoert.

#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;
}

Korte toets

Toets je begrip van de prestaties van reguliere expressies.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd hoe je reguliere expressies efficiënt gebruikt:

compileer patronen één keer, bij voorkeur als static const, en gebruik ze opnieuw
kies de juiste grammatica en overweeg optimize
voorkom catastrofaal terugzoeken en veranker waar mogelijk
gebruik eenvoudigere hulpmiddelen zoals find voor vaste deelreeksen en meet wijzigingen

Daarmee is de cursus Reguliere expressies voltooid.

Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Opmerkingen over prestaties” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Opmerkingen over prestaties”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “Opmerkingen over prestaties”?

Compileer patronen verstandig Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Opmerkingen over prestaties”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C++ Academy