Biblioteca de expresiones regulares

La biblioteca de expresiones regulares proporciona una clase que representa expresiones regulares, que son una especie de mini-lenguaje que se utiliza para realizar coincidencias de patrones dentro de cadenas. Casi todas las operaciones con expresiones regulares se pueden caracterizar operando en varios de los siguientes objetos:

• Secuencia de destino. La secuencia de caracteres que se busca para un patrón. Este puede ser un rango especificado por dos iteradores, una cadena de caracteres terminada en nulo o un std::string.

• Patrón. Esta es la expresión regular en sí misma. Determina qué constituye una coincidencia. Es un objeto de tipo std::basic_regex, construido a partir de una cadena con una sintaxis especial. Véase regex_constants::syntax_option_type para obtener una descripción de las variaciones de sintaxis admitidas.

• Array de coincidencias. La información sobre coincidencias se puede recuperar como un objeto de tipo std::match_results.

• Cadena de reemplazo. Esta es una cadena que determina cómo reemplazar las coincidencias. Véase regex_constants::match_flag_type para obtener una descripción de las variaciones de sintaxis admitidas.

[editar] Clases principales

Estas clases encapsulan una expresión regular y los resultados de hacer coincidir una expresión regular dentro de una secuencia objetivo de caracteres.

[editar] Algoritmos

Estas funciones se utilizan para aplicar la expresión regular encapsulada en una expresión regular a una secuencia de caracteres de destino.

[editar] Iteradores

Los iteradores de expresiones regulares se utilizan para recorrer todo el conjunto de coincidencias de expresiones regulares encontrado dentro de una secuencia.

[editar] Excepciones

Esta clase define el tipo de objetos lanzados como excepciones para reportar errores de la biblioteca de expresiones regulares.

[editar] Rasgos de tipo

La clase de rasgos de expresiones regulares se utiliza para encapsular los aspectos localizables de una expresión regular.

[editar] Constantes

[editar] Ejemplo

#include <iostream>
#include <iterator>
#include <string>
#include <regex>
 
int main()
{
    std::string s = "Algunas personas, cuando se enfrentan a un problema, piensan "
        "\"Lo sé, usaré expresiones regulares.\" "
        "Ahora tienen dos problemas.";
 
    std::regex self_regex("EXPRESIONES REGULARES",
            std::regex_constants::ECMAScript | std::regex_constants::icase);
    if (std::regex_search(s, self_regex)) {
        std::cout << "El texto contiene la frase 'expresiones regulares'\n";
    }
 
    std::regex word_regex("(\\w+)");
    auto words_begin = 
        std::sregex_iterator(s.begin(), s.end(), word_regex);
    auto words_end = std::sregex_iterator();
 
    std::cout << "Se encontraron "
              << std::distance(words_begin, words_end)
              << " palabras\n";
 
    const int N = 6;
    std::cout << "Palabras de más de " << N << " caracteres:\n";
    for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
        std::smatch match = *i;
        std::string match_str = match.str();
        if (match_str.size() > N) {
            std::cout << "  " << match_str << '\n';
        }
    }
 
    std::regex long_word_regex("(\\w{7,})");
    std::string new_s = std::regex_replace(s, long_word_regex, "[$&]");
    std::cout << new_s << '\n';
}

El texto contiene la frase 'expresiones regulares'
Se encontraron 18 palabras
Palabras de más de 6 caracteres:
  Algunas
  personas
  enfrentan
  problema
  piensan
  expresiones
  regulares
  problemas
[Algunas] [personas], cuando se [enfrentan] a un [problema], [piensan]
"Lo sé, usaré [expresiones] [regulares]" Ahora tienen dos [problemas].