std::regex_iterator
| Definido en el archivo de encabezado <regex>
|
||
template< class BidirIt, class CharT = typename std::iterator_traits<BidirIt>::value_type, class Traits = std::regex_traits<CharT> > class regex_iterator |
(desde C++11) | |
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>).
Requerimientos de tipo
-BidirIt debe satisfacer los requisitos de BidirectionalIterator.
|
Especializaciones
Se definen varias especializaciones para los tipos de secuencias de caracteres comunes:
Definido en el archivo de encabezado
<regex> | |
| Tipo | Definición |
cregex_iterator
|
regex_iterator<const char*>
|
wcregex_iterator
|
regex_iterator<const wchar_t*>
|
sregex_iterator
|
regex_iterator<std::string::const_iterator>
|
wsregex_iterator
|
regex_iterator<std::wstring::const_iterator>
|
Tipos miembro
| Tipo miembro | Definición |
value_type
|
std::match_results<BidirIt>
|
difference_type
|
std::ptrdiff_t |
pointer
|
const value_type*
|
reference
|
const value_type&
|
iterator_category
|
std::forward_iterator_tag |
regex_type
|
basic_regex<CharT, Traits>
|
Funciones miembro
Construye un nuevo objeto regex_iterator. (función miembro pública) | |
(destructor) (implícitamente declarado) |
Destruye un objeto regex_iterator, incluyendo el valor almacenado en caché. (función miembro pública) |
| Asigna el contenido. (función miembro pública) | |
(eliminado en C++20) |
Compara dos objetos regex_iterator. (función miembro pública) |
| Accede a la coincidencia actual. (función miembro pública) | |
| Avanza el iterador a la coincidencia siguiente. (función miembro pública) |
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.
Ejemplo
Demuestra una búsqueda de coincidencias para palabras usando iteradores de expresiones regulares.
#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';
}
}
Salida:
Se encontraron 3 palabras:
La
zorra
veloz.
Véase también
(C++11) |
Identifica una coincidencia de expresión regular, incluyendo todas las coincidencias de subexpresión. (plantilla de clase) |
(C++11) |
Intenta coincidir una expresión regular con cualquier parte de una secuencia de caracteres. (plantilla de función) |