C++ Academy · Aula

Observações sobre desempenho

Compile padrões com critério

Observações sobre desempenho é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

A compilação é dispendiosa

Criar um std::regex a partir de uma cadeia compila o padrão, o que é dispendioso. O maior ganho vem de compilar uma vez e reutilizar.

Evite construir expressões regulares dentro de laços.
Compile na inicialização ou no primeiro uso.

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

Reutilização de um padrão compilado

Construa o padrão uma vez, fora do laço, e reutilize-o para cada entrada. Reconstruí-lo a cada iteração desperdiça 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;
}

Constantes estáticas

Para um padrão que nunca muda, declare-o como static const dentro de uma função, para que seja compilado exatamente uma vez em todas as chamadas.

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

Escolha a gramática adequada

A variante da expressão regular (a gramática) afeta a velocidade e os recursos. std::regex::ECMAScript é o padrão e a opção mais completa; std::regex::basic ou extended são mais simples e, às vezes, mais rápidas.

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

Sinalizador de otimização

Adicionar std::regex::optimize informa ao mecanismo que ele deve gastar mais tempo construindo o padrão em troca de uma correspondência mais rápida, o que compensa quando você faz muitas correspondências.

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

Evite retrocesso catastrófico

Quantificadores aninhados, como (a+)+, podem resultar em tempo exponencial para determinadas entradas. Prefira padrões mais simples e não ambíguos.

#include <iostream>
#include <regex>

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

Use âncoras quando possível

Usar âncoras com ^ e $ permite que o mecanismo falhe rapidamente, em vez de tentar todas as posições iniciais.

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

Prefira ferramentas simples quando possível

Se você precisar apenas verificar uma parte fixa da cadeia, std::string::find será muito mais rápido que uma expressão regular. Reserve as expressões regulares para correspondências de padrões genuínas.

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

Reutilização do objeto de correspondência

Ao fazer pesquisas repetidamente, reutilize um único std::smatch em vez de criar um novo a cada vez, para reduzir a sobrecarga.

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

Restrinja o seu padrão

Classes de caracteres específicas fazem a correspondência de forma mais rápida e segura do que o ponto coringa. Prefira [0-9] a . quando quiser corresponder a dígitos.

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

Meça antes de otimizar

Combine o que aprendeu sobre <chrono>: cronometre o uso da sua expressão regular para confirmar que uma alteração realmente ajuda antes de adotá-la.

#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ção rápida

Teste a sua compreensão sobre o desempenho das expressões regulares.

Recapitulação

Você aprendeu a usar expressões regulares com eficiência:

compile os padrões uma vez, de preferência como static const, e reutilize-os
escolha a gramática adequada e considere optimize
evite retrocesso catastrófico e use âncoras quando possível
use ferramentas mais simples, como find, para trechos fixos, e meça as alterações

Isso conclui o curso de Expressões Regulares.

Perguntas Frequentes

A aula “Observações sobre desempenho” é grátis?

Sim — o texto completo de “Observações sobre desempenho” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Observações sobre desempenho”?

Compile padrões com critério Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Observações sobre desempenho”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy