std::ranges::views::split, std::ranges::split_view
| Definido en el archivo de encabezado <ranges>
|
||
| template< ranges::forward_range V, ranges::forward_range Pattern > requires ranges::view<V> && ranges::view<Pattern> && |
(1) | (desde C++20) |
| namespace views { inline constexpr /*no especificado*/ split = /*no especificado*/; |
(2) | (desde C++20) |
| Signatura de la llamada |
||
| template< ranges::viewable_range R, class Pattern > requires /* véase a continuación */ |
(desde C++20) | |
| template< class Pattern > constexpr /*cierre de adaptador de rango*/ split( Pattern&& pattern ); |
(desde C++20) | |
split_view toma una vista (view) y un delimitador, y divide la vista en subrangos en el delimitador.split_view modela los conceptos forward_range, y common_range cuando la vista subyacente V modela los conceptos respectivos.
El rango interno (ranges::range_reference_t<split_view>) es un ranges::subrange<ranges::iterator_t<V>>, que modela common_range, modela sized_range cuando ranges::iterator_t<V> modela std::sized_sentinel_for<ranges::iterator_t<V>>, y modela contiguous_range, random_access_range, bidirectional_range, y forward_range cuando V modela los conceptos respectivos.
Contenido |
Equivalente en expresión
La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept (e) == noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.
Datos miembro
Las implementaciones típicas de split_view mantienen tres datos miembro no estáticos:
- la vista subyacente de tipo
V(que aquí se muestra comobase_solo de exposición), y - el patrón (que aquí se muestra como
pattern_solo de exposición) que se utiliza para dividir la vista subyacente; - un objeto equivalente a std::optional<ranges::subrange<ranges::iterator_t<V>>> (que aquí se muestra como
cached_begin_solo de exposición) que almacena en caché el resultado de una primera llamada abegin().
Funciones miembro
| (C++20) |
Construye un objeto split_view (función miembro pública) |
| (C++20) |
Devuelve una copia de la vista (adaptada) subyacente. (función miembro pública) |
| (C++20) |
Devuelve un iterador al comienzo. (función miembro pública) |
| (C++20) |
Devuelve un iterador o un centinela al final. (función miembro pública) |
| (C++20) |
searches for the next occurrence of the pattern (función miembro de solo exposición) |
Heredadas de std::ranges::view_interface | |
| (C++20) |
Devuelve si la vista derivada está vacía o no. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
|
| (C++20) |
Devuelve si la vista derivada está vacía o no. Se proporciona si ranges::empty le es aplicable. (función miembro pública de std::ranges::view_interface<D>)
|
| (C++20) |
Devuelve el primer elemento en la vista derivada. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
|
Clases anidadas
| (C++20) |
El tipo iterador. (clase miembro de solo exposición) |
| (C++20) |
El tipo centinela. (clase miembro de solo exposición) |
Guías de deducción
Notas
Antes de P2210R2, split_view usaba un mecanismo perezoso para dividir, y por lo tanto no podía mantener las propiedades bidireccionales, de acceso aleatorio o contiguas de la vista subyacente, o hacer al tipo iterador del rango interno el mismo que el de la vista subyacente. Consecuentemente, se rediseño por P2210R2, y el mecanismo perezoso se movió a lazy_split_view.
Ejemplo
Un enlace para verificar el ejemplo: wandbox
#include <iostream> #include <iomanip> #include <ranges> #include <string_view> int main() { constexpr std::string_view palabras{"Hola-_-C++-_-20-_-!"}; constexpr std::string_view delim{"-_-"}; for (const auto palabra : std::views::split(palabras, delim)) { std::cout << std::quoted(std::string_view(palabra.begin(), palabra.end())) << ' '; } }
Salida:
"Hola" "C++" "20" "!"
Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| P2210R2 | C++20 | La vista split_view antigua era demasiado perezosa para usarse fácilmente.
|
Se rediseñó. |
Véase también
Una vista (view) sobre los subrangos obtenidos al separar otra vista (view) usando un delimitador. (plantilla de clase) (objeto adaptador de rango) | |
| (C++20) |
Una vista (view) que consiste en la secuencia obtenida al aplanar una vista de rangos (range). (plantilla de clase) (objeto adaptador de rango) |
