std::regex_token_iterator - cppreference.com

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).

Requerimientos de tipo

Especializaciones

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

Tipos miembro

Funciones miembro

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.

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