std::regex_token_iterator

std::regex_token_iterator es un ForwardIterator de solo lectura que accede a las subcoincidencias individuales de cada coincidencia de una expresión regular dentro de la secuencia de caracteres subyacentes. También se puede usar para acceder a las partes de la secuencia que no se coincidieron por una expresión regular dada (p. ej., como un tokenizador).

Durante la construcción, construye un std::regex_iterator y en cada incremento pasa a través de las subcoincidencias solicitadas del objeto std::match_results actual, incrementando el regex_iterator subyacente cuando la incrementación se aleja de la última subcoincidencia.

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

Justo antes de volverse el iterador al final de la secuencia, un std::regex_token_iterator puede volverse un iterador de sufijo, si el índice -1 (un fragmento no coincidido) aparece en la lista de los índices de la subcoincidencia solicitada. Dicho iterador, si se desreferencia, devuelve un objeto std::match_results correspondiente a la secuencia de caracteres entre la última coincidencia y el final de la secuencia.

Una implementación habitual de std::regex_token_iterator alberga el iterador std::regex_iterator subyacente, un contenedor (p. ej., std::vector<int>) de los índices de la subcoincidencia solicitada, el contador interno igual al índice de la subcoincidencia, un puntero a std::sub_match, que apunta a la subcoincidencia actual de la coincidencia actual, y un objeto std::match_results que contiene la última secuencia de caracteres que no coincidieron (usados en la modalidad tokenizador).

[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 std::regex_iterator, que almacena un puntero a la expresión regular, incrementar el iterador después de que se destruyó la expresión regular resulta en comportamiento no definido.

[editar] Ejemplo

#include <fstream>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <regex>
 
int main()
{
    // Tokenización (fragmentos que no coincidieron)
    // Observa que la expresión regular se coincide solo dos veces;
    // cuando el tercer valor se obtiene, el iterador es un iterador de sufijo.
    const std::string texto = "La zorra veloz.";
    const std::regex er_espacio("\\s+"); // espacio en blanco
    std::copy( std::sregex_token_iterator(texto.begin(), texto.end(), er_espacio, -1),
               std::sregex_token_iterator(),
               std::ostream_iterator<std::string>(std::cout, "\n"));
 
    std::cout << '\n';
 
    // Iterar sobre las primeras subcoincidencias
    const std::string html = R"(<p><a href="http://google.com.mx">google</a> )"
                             R"(< a HREF ="http://es.cppreference.com">cppreference</a>\n</p>)";
    const std::regex er_url(R"!!(<\s*A\s+[^>]*href\s*=\s*"([^"]*)")!!", std::regex::icase);
    std::copy( std::sregex_token_iterator(html.begin(), html.end(), er_url, 1),
               std::sregex_token_iterator(),
               std::ostream_iterator<std::string>(std::cout, "\n"));
}

La
zorra
veloz.
 
http://google.com.mx
http://es.cppreference.com