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 subyacente. Cumple con los requisitos de un LegacyForwardIterator , excepto que para valores dereferenciables a y b con a == b , * a y * b no estarán vinculados al mismo objeto.

Al construir, y en cada incremento, llama a std::regex_search y recuerda el resultado (es decir, guarda una copia del valor std:: match_results < BidirIt > ). El primer objeto puede leerse cuando se construye el iterador o cuando se realiza la primera desreferenciación. De lo contrario, la desreferenciación solo devuelve una copia de la coincidencia de regex obtenida más recientemente.

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

Una implementación típica de std::regex_iterator mantiene los iteradores de inicio y fin para 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 > ).

Requisitos de tipo

Especializaciones

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

Tipos de miembros

Miembros de datos

Funciones miembro

Notas

Es responsabilidad del programador garantizar que el objeto std::basic_regex pasado al constructor del iterador sobreviva al iterador. Debido a que el iterador almacena un puntero al regex, incrementar el iterador después de que el regex haya sido destruido accede a un puntero colgante.

Si la parte de la expresión regular que coincide 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 .

Ejemplo

#include <iostream>
#include <iterator>
#include <regex>
#include <string>
int main()
{
    const std::string s = "Quick brown fox.";
    std::regex words_regex("[^\\s]+");
    auto words_begin = std::sregex_iterator(s.begin(), s.end(), words_regex);
    auto words_end = std::sregex_iterator();
    std::cout << "Found " << std::distance(words_begin, words_end) << " words:\n";
    for (std::sregex_iterator i = words_begin; i != words_end; ++i)
    {
        std::smatch match = *i;
        std::string match_str = match.str();
        std::cout << match_str << '\n';
    }
}

Found 3 words:
Quick
brown
fox.

Informes de defectos

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

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

Véase también