0Pricing
C++ Academy · Lezione

Note sulle prestazioni

Compilare i pattern con criterio

Note sulle prestazioni è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

La compilazione è costosa

La creazione di un std::regex a partire da una stringa compila il pattern, un'operazione costosa. Il vantaggio maggiore consiste nel compilare una sola volta e riutilizzare.

  • Evitate di costruire una regex all'interno dei cicli.
  • Compilatela all'avvio o al primo utilizzo.
#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;
}

Riutilizzare un pattern compilato

Costruite il pattern una volta fuori dal ciclo e riutilizzatelo per ogni input. Ricostruirlo a ogni iterazione fa perdere tempo.

#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 per le costanti

Per un pattern che non cambia mai, dichiaratelo static const all'interno di una funzione, così verrà compilato una sola volta per tutte le chiamate.

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

Scegliere la grammatica corretta

La variante di regex (grammatica) influisce sulla velocità e sulle funzionalità. std::regex::ECMAScript è quella predefinita e più ricca; std::regex::basic o extended sono più semplici e talvolta più veloci.

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

Flag optimize

Aggiungere std::regex::optimize indica al motore di dedicare più tempo alla costruzione del pattern in cambio di un matching più rapido; questo è vantaggioso quando eseguite il matching molte volte.

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

Evitare il backtracking catastrofico

Quantificatori annidati come (a+)+ possono causare una crescita esponenziale del tempo di esecuzione con determinati input. Preferite pattern più semplici e privi di ambiguità.

#include <iostream>
#include <regex>

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

Utilizzare gli ancoraggi quando possibile

Gli ancoraggi con ^ e $ consentono al motore di interrompere rapidamente la ricerca invece di provare ogni posizione iniziale.

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

Preferire strumenti semplici quando possibile

Se vi serve solo verificare la presenza di una sottostringa fissa, std::string::find è molto più veloce di una regex. Utilizzate le regex solo per la ricerca di pattern reali.

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

Riutilizzare l'oggetto match

Quando eseguite ricerche ripetute, riutilizzate un singolo std::smatch invece di allocarne uno nuovo ogni volta, così ridurrete l'overhead.

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

Restringere il pattern

Le classi di caratteri specifiche fanno il match più velocemente e in modo più sicuro rispetto al punto generico. Preferisca [0-9] a . quando intende indicare delle cifre.

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

Misurare prima di ottimizzare

Metta in pratica ciò che ha imparato su <chrono>: misuri i tempi dell'uso delle regex per verificare che una modifica sia realmente utile prima di adottarla.

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

Verifica rapida

Verifichi la Sua comprensione delle prestazioni delle regex.

Riepilogo

Ha imparato a usare le regex in modo efficiente:

  • compili i pattern una sola volta, idealmente come static const, e li riutilizzi
  • scelga la grammatica corretta e valuti l'uso di optimize
  • eviti il backtracking catastrofico e ancori il pattern quando possibile
  • usi strumenti più semplici come find per le sottostringhe fisse e misuri le modifiche

Ha completato il corso sulle espressioni regolari.

Domande Frequenti

La lezione «Note sulle prestazioni» è gratuita?

Sì — il testo completo di «Note sulle prestazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Note sulle prestazioni»?

Compilare i pattern con criterio Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Note sulle prestazioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Nozioni di base su regex
  2. Gruppi di cattura
  3. Ricerca e sostituzione
  4. Note sulle prestazioni
← Torna a C++ Academy