std:: regex_token_iterator

std::regex_token_iterator es un LegacyForwardIterator de solo lectura que accede a las subcoincidencias individuales de cada coincidencia de una expresión regular dentro de la secuencia de caracteres subyacente. También puede utilizarse para acceder a las partes de la secuencia que no coincidieron con la expresión regular dada (por ejemplo, como un tokenizador).

Al construir, construye un std::regex_iterator y en cada incremento recorre las subcoincidencias solicitadas desde el match_results actual, incrementando el std::regex_iterator subyacente cuando se incrementa más allá de la última subcoincidencia.

El iterador construido por defecto std::regex_token_iterator es el iterador de fin de secuencia. Cuando un std::regex_token_iterator válido se incrementa después de alcanzar la última subcoincidencia de la última coincidencia, se vuelve igual al iterador de fin de secuencia. Desreferenciarlo o incrementarlo más allá invoca comportamiento indefinido.

Justo antes de convertirse en el iterador de fin de secuencia, un std::regex_token_iterator puede convertirse en un suffix iterator , si el índice - 1 (fragmento no coincidente) aparece en la lista de los índices de subcoincidencia solicitados. Tal iterador, si se desreferencia, devuelve un match_results correspondiente a la secuencia de caracteres entre la última coincidencia y el fin de la secuencia.

Una implementación típica de std::regex_token_iterator mantiene el std::regex_iterator subyacente, un contenedor (por ejemplo std:: vector < int > ) de los índices de subcoincidencia solicitados, el contador interno igual al índice de la subcoincidencia, un puntero a std::sub_match , apuntando a la subcoincidencia actual de la coincidencia actual, y un objeto std::match_results que contiene la última secuencia de caracteres no coincidentes (utilizado en modo tokenizador).

Requisitos de tipo

Especializaciones

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

Tipos de miembros

Funciones miembro

Notas

Es responsabilidad del programador 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 al regex, incrementar el iterador después de que el regex haya sido destruido resulta en comportamiento indefinido.

Ejemplo

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <regex>
int main()
{
    // Tokenización (fragmentos no coincidentes)
    // Nótese que la expresión regular coincide solo dos veces; cuando se obtiene el tercer valor
    // el iterador es un iterador de sufijo.
    const std::string text = "Quick brown fox.";
    const std::regex ws_re("\\s+"); // espacio en blanco
    std::copy(std::sregex_token_iterator(text.begin(), text.end(), ws_re, -1),
              std::sregex_token_iterator(),
              std::ostream_iterator<std::string>(std::cout, "\n"));
    std::cout << '\n';
    // Iterando las primeras subcoincidencias
    const std::string html = R"(<p><a href="http://google.com">google</a> )"
                             R"(< a HREF ="http:https://es.cppreference.net">cppreference</a>\n</p>)";
    const std::regex url_re(R"!!(<\s*A\s+[^>]*href\s*=\s*"([^"]*)")!!", std::regex::icase);
    std::copy(std::sregex_token_iterator(html.begin(), html.end(), url_re, 1),
              std::sregex_token_iterator(),
              std::ostream_iterator<std::string>(std::cout, "\n"));
}

Quick
brown
fox.
http://google.com
https://es.cppreference.net

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

1. ↑ iterator_category no fue modificado por la resolución, porque cambiarlo a std::input_iterator_tag podría romper demasiado código existente.