C++ Academy · Leçon

Remarques sur les performances

Compiler judicieusement les motifs

Remarques sur les performances est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Compilation coûteuse

Construire un std::regex à partir d'une chaîne compile le motif, ce qui est coûteux. Le gain le plus important consiste à le compiler une seule fois, puis à le réutiliser.

Évitez de construire une expression régulière dans une boucle.
Compilez-la au démarrage ou lors de la première utilisation.

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

Réutiliser un motif compilé

Construisez le motif une seule fois, en dehors de la boucle, puis réutilisez-le pour chaque entrée. Le reconstruire à chaque itération fait perdre du temps.

#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 pour les constantes

Pour un motif qui ne change jamais, déclarez-le static const dans une fonction afin qu'il soit compilé exactement une fois pour l'ensemble des appels.

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

Choisir la bonne grammaire

La variante d'expression régulière (la grammaire) influe sur la vitesse et les fonctionnalités. std::regex::ECMAScript est la valeur par défaut et la plus riche ; std::regex::basic ou extended sont plus simples et parfois plus rapides.

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

Indicateur optimize

Ajouter std::regex::optimize indique au moteur de consacrer davantage de temps à la construction du motif en échange d'une correspondance plus rapide, ce qui est avantageux lorsque vous effectuez de nombreuses correspondances.

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

Éviter le retour arrière catastrophique

Des quantificateurs imbriqués comme (a+)+ peuvent entraîner un temps d'exécution exponentiel pour certaines entrées. Préférez des motifs plus simples et dépourvus d'ambiguïté.

#include <iostream>
#include <regex>

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

Ancrer lorsque c'est possible

Les ancres ^ et $ permettent au moteur d'échouer rapidement au lieu d'essayer chaque position de départ.

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

Privilégier les outils simples lorsque c'est possible

Si vous avez seulement besoin de vérifier la présence d'une sous-chaîne fixe, std::string::find est bien plus rapide qu'une expression régulière. Réservez les expressions régulières aux véritables recherches par motif.

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

Réutiliser l'objet de correspondance

Lors de recherches répétées, réutilisez un seul std::smatch plutôt que d'en allouer un nouveau à chaque fois, afin de réduire la surcharge.

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

Affinez votre motif

Les classes de caractères spécifiques correspondent plus rapidement et plus sûrement que le point générique. Préférez [0-9] à . lorsque vous voulez représenter des chiffres.

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

Mesurez avant d'optimiser

Mettez en pratique ce que vous avez appris sur <chrono> : mesurez le temps d'exécution de vos expressions régulières pour vérifier qu'une modification est réellement utile avant de l'adopter.

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

Vérification rapide

Vérifiez votre compréhension des performances des expressions régulières.

Récapitulatif

Vous avez appris à utiliser efficacement les expressions régulières :

compilez les motifs une seule fois, idéalement en static const, puis réutilisez-les
choisissez la grammaire appropriée et envisagez optimize
évitez les retours en arrière catastrophiques et utilisez des ancres lorsque c'est possible
utilisez des outils plus simples comme find pour les sous-chaînes fixes, et mesurez les modifications

Le cours sur les expressions régulières est terminé.

Questions Fréquemment Posées

La leçon « Remarques sur les performances » est-elle gratuite ?

Oui — le texte complet de « Remarques sur les performances » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Remarques sur les performances » ?

Compiler judicieusement les motifs Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Remarques sur les performances » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy