std::regex_iterator

std::regex_iterator es un iterador de solo lectura que accede a las coincidencias individuales de una expresión regular dentro de la secuencia de caracteres subyacentes. Cumple con los requisitos de un ForwardIterator, excepto que para los valores desreferenciables a y b con a == b, *a y *b no estarán vinculados al mismo objeto.

Durante la construcción, y en cada incremento, llama a std::regex_search y recuerda el resultado (es decir, guarda una copia del valor std::match_results<BidirIt>). Se puede leer el primer objeto cuando se construye el iterador o cuando se realiza la primera desreferencia. De lo contrario, la deferencia solo devuelve una copia de la coincidencia de la expresión regular obtenida más recientemente.

El iterador std::regex_iterator construido por defecto es el iterador al final de la secuencia. Cuando un iterador std::regex_iterator válido se incrementa después de alcanzar la última coincidencia, (std::regex_search devuelve false), se hace igual al iterador al final de la secuencia. Desreferenciarlo o incrementarlo más allá resulta en comportamiento no definido.

Una implementación habitual de std::regex_iterator alberga los iteradores al principio y al final de la secuencia subyacente (dos instancias de BidirIt), un puntero a la expresión regular (const regex_type*), los indicadores de coincidencia (std::regex_constants::match_flag_type), y la coincidencia actual (std::match_results<BidirIt>).

[editar] Requerimientos de tipo

[editar] Especializaciones

Se definen varias especializaciones para los tipos de secuencias de caracteres comunes:

[editar] Tipos miembro

[editar] Funciones miembro

[editar] Notas

La responsabilidad del programador es asegurar que el objeto std::basic_regex pasado al constructor del iterador sobreviva al iterador. Debido a que el iterador almacena un puntero a la expresión regular, incrementar el iterador después de que se destruyó la expresión regular accede a un puntero pendiente.

Si la parte de la expresión regular que coincidió es solo una aserción (^, $, \b, \B), la coincidencia almacenada en el iterador es una coincidencia de longitud cero; es decir, match[0].first == match[0].second.

[editar] Ejemplo

#include <regex>
#include <iterator>
#include <iostream>
#include <string>
 
int main()
{
    const std::string s = "La zorra veloz.";
 
    std::regex er_palabras("[^\\s]+"); // expresión regular para palabras
    auto principio = 
        std::sregex_iterator(s.begin(), s.end(), er_palabras);
    auto fin = std::sregex_iterator();
 
    std::cout << "Se encontraron " 
              << std::distance(principio, fin) 
              << " palabras:\n";
 
    for (std::sregex_iterator i = principio; i != fin; ++i) {
        std::smatch coincidencia = *i;                                                 
        std::string cadena = coincidencia.str(); 
        std::cout << cadena << '\n';
    }   
}

Se encontraron 3 palabras:
La
zorra
veloz.

[editar] Véase también