C++ Academy · Lección

Notas de rendimiento

Compile los patrones con criterio

Lección 4 de 413 pasos

Notas de rendimiento es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

La compilación es costosa

Crear un std::regex a partir de una cadena compila el patrón, lo que resulta costoso. La mayor mejora consiste en compilarlo una vez y reutilizarlo.

Evite construir expresiones regulares dentro de bucles.
Compile al iniciar el programa o durante el primer 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;
}

Reutilizar un patrón compilado

Construya el patrón una sola vez fuera del bucle y reutilícelo para cada entrada. Reconstruirlo en cada iteración desperdicia tiempo.

#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 para constantes

Para un patrón que nunca cambia, declárelo como static const dentro de una función para que se compile exactamente una vez en todas las llamadas.

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

Elegir la gramática adecuada

La variedad de expresiones regulares (gramática) afecta a la velocidad y las funcionalidades. std::regex::ECMAScript es la opción predeterminada y la que ofrece más funcionalidades; std::regex::basic o extended son más sencillas y, en ocasiones, más 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;
}

Bandera optimize

Añadir std::regex::optimize indica al motor que dedique más tiempo a construir el patrón a cambio de acelerar las coincidencias, lo que resulta rentable cuando realiza muchas coincidencias.

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

Evitar el backtracking catastrófico

Los cuantificadores anidados, como (a+)+, pueden provocar un tiempo exponencial con ciertas entradas. Prefiera patrones más sencillos y sin ambigüedades.

#include <iostream>
#include <regex>

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

Anclar cuando sea posible

Anclar con ^ y $ permite que el motor falle rápidamente en lugar de probar todas las posiciones iniciales.

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

Preferir herramientas sencillas cuando sea posible

Si solo necesita comprobar una subcadena fija, std::string::find es mucho más rápido que una expresión regular. Reserve las expresiones regulares para las coincidencias de patrones reales.

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

Reutilizar el objeto de coincidencia

Al realizar búsquedas repetidamente, reutilice un único std::smatch en lugar de crear uno nuevo cada vez, para reducir la 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;
}

Acote su patrón

Las clases de caracteres específicas coinciden más rápido y de forma más segura que el punto comodín. Prefiera [0-9] en lugar de . cuando se refiera 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;
}

Mida antes de optimizar

Combine lo que aprendió sobre <chrono>: mida el tiempo de uso de sus expresiones regulares para confirmar que un cambio realmente ayuda antes de adoptarlo.

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

Comprobación rápida

Compruebe cuánto entiende sobre el rendimiento de las expresiones regulares.

Responde en la lección interactiva

Repaso

Aprendió a usar las expresiones regulares de forma eficiente:

compile los patrones una sola vez, idealmente como static const, y reutilícelos
elija la gramática adecuada y considere optimize
evite el retroceso catastrófico y ancle los patrones cuando sea posible
use herramientas más sencillas como find para subcadenas fijas y mida los cambios

Con esto completa el curso de Expresiones regulares.

Gratis para empezar

Aprende C++ con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 51
Lecciones: 203

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Notas de rendimiento» es gratis?

Sí — el texto completo de «Notas de rendimiento» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Notas de rendimiento»?

Compile los patrones con criterio Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Notas de rendimiento»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy