Regular expressions library (since C++11)

La biblioteca de expresiones regulares proporciona una clase que representa expresiones regulares , las cuales son un tipo de mini-lenguaje utilizado para realizar coincidencia de patrones dentro de cadenas. Casi todas las operaciones con regexes pueden caracterizarse operando sobre varios de los siguientes objetos:

• Secuencia objetivo . La secuencia de caracteres en la que se busca un patrón. 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í. Determina lo que constituye una coincidencia. Es un objeto de tipo std::basic_regex , construido a partir de una cadena con una gramática especial.

• Arreglo coincidente . La información sobre coincidencias puede recuperarse como un objeto de tipo std::match_results .

• Cadena de reemplazo . Esta es una cadena que determina cómo reemplazar las coincidencias.

Gramáticas de expresiones regulares

Los patrones y cadenas de reemplazo admiten las siguientes gramáticas de expresiones regulares:

• Gramática de expresiones regulares ECMAScript modificada . Esta es la gramática predeterminada.
• Gramática básica de expresiones regulares POSIX .
• Gramática extendida de expresiones regulares POSIX .
• La gramática de expresiones regulares utilizada por la utilidad awk en POSIX.
• La gramática de expresiones regulares utilizada por la utilidad grep en POSIX. Esto es efectivamente igual a la gramática básica de expresiones regulares POSIX, con la adición de nueva línea ' \n ' como separador de alternancia.
• La gramática de expresiones regulares utilizada por la utilidad grep , con la opción - E , en POSIX. Esto es efectivamente igual a la gramática extendida de expresiones regulares POSIX, con la adición de nueva línea ' \n ' como separador de alternancia además de '|' .

También están disponibles algunas variaciones gramaticales (como la coincidencia sin distinción entre mayúsculas y minúsculas), consulte esta página para más detalles.

Clases principales

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

Algoritmos

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

Iteradores

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

Excepciones

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

Rasgos

La clase de rasgos de regex se utiliza para encapsular los aspectos localizables de una regex.

Constantes

Ejemplo

#include <iostream>
#include <iterator>
#include <regex>
#include <string>
int main()
{
    std::string s = "Some people, when confronted with a problem, think "
        "\"I know, I'll use regular expressions.\" "
        "Now they have two problems.";
    std::regex self_regex("REGULAR EXPRESSIONS",
        std::regex_constants::ECMAScript | std::regex_constants::icase);
    if (std::regex_search(s, self_regex))
        std::cout << "Text contains the phrase 'regular expressions'\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 << "Found "
              << std::distance(words_begin, words_end)
              << " words\n";
    const int N = 6;
    std::cout << "Words longer than " << N << " characters:\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';
}

Text contains the phrase 'regular expressions'
Found 20 words
Words longer than 6 characters:
  confronted
  problem
  regular
  expressions
  problems
Some people, when [confronted] with a [problem], think 
"I know, I'll use [regular] [expressions]." Now they have two [problems].