Namespaces
Variants

std::ranges:: views:: split, std::ranges:: split_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::split_view
Défini dans l'en-tête <ranges>
template < ranges:: forward_range V, ranges:: forward_range Pattern >

requires ranges:: view < V > &&
ranges:: view < Pattern > &&
std:: indirectly_comparable < ranges:: iterator_t < V > ,
ranges:: iterator_t < Pattern > ,
ranges:: equal_to >
class split_view

: public ranges:: view_interface < split_view < V, Pattern >>
(1) (depuis C++20)
namespace views {

inline constexpr /* non spécifié */ split = /* non spécifié */ ;

}
(2) (depuis C++20)
Signature d'appel
template < ranges:: viewable_range R, class Pattern >

requires /* voir ci-dessous */

constexpr ranges:: view auto split ( R && r, Pattern && pattern ) ;
(depuis C++20)
template < class Pattern >
constexpr /* adaptateur de gamme de fermeture */ split ( Pattern && pattern ) ;
(depuis C++20)
1) split_view prend une view et un délimiteur, et divise la view en sous-intervalles sur le délimiteur.
2) RangeAdaptorObject . L'expression views :: split ( e, p ) est équivalente en expression à split_view ( e, p ) pour toutes sous-expressions appropriées e et p .

split_view modélise les concepts forward_range , et common_range lorsque la view sous-jacente V modélise les concepts respectifs.

La plage interne ( ranges:: range_reference_t < split_view > ) est un ranges:: subrange < ranges:: iterator_t < V >> , qui modélise common_range , modélise sized_range lorsque ranges:: iterator_t < V > modélise std:: sized_sentinel_for < ranges:: iterator_t < V >> , et modélise contiguous_range , random_access_range , bidirectional_range , et forward_range lorsque V modélise les concepts respectifs.

Contrairement à lazy_split_view , split_view préserve la continuité du sous-intervalle, le rendant adapté au fractionnement de chaînes.

Table des matières

Membres de données

Membre Description
V base_ (privé) la vue sous-jacente (adaptée) view
( objet membre d'exposition uniquement* )
Pattern pattern_ (privé) l'objet motif utilisé comme délimiteur pour diviser la view sous-jacente
( objet membre d'exposition uniquement* )
non-propagating-cache < ranges:: subrange
< ranges:: iterator_t < V >>> cached_begin_ (privé) 		un objet qui met en cache le résultat du premier appel à begin()
( objet membre d'exposition uniquement* )

Fonctions membres

construit un split_view
(fonction membre publique)
retourne une copie de la vue sous-jacente (adaptée)
(fonction membre publique)
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur ou un sentinelle vers la fin
(fonction membre publique)
recherche la prochaine occurrence du motif
( fonction membre d'exposition uniquement* )
Hérité de std::ranges::view_interface
retourne si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un itérateur constant vers le début de la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
retourne si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )

Classes imbriquées

le type d'itérateur
( classe membre d'exposition uniquement* )
le type de sentinelle
( classe membre d'exposition uniquement* )

Guides de déduction

Notes

Avant P2210R2 , split_view utilisait un mécanisme lazy pour le fractionnement, et ne pouvait donc pas conserver les propriétés bidirectionnelles, d'accès aléatoire ou contiguës de la vue sous-jacente, ni rendre le type d'itérateur de la plage interne identique à celui de la vue sous-jacente. Par conséquent, il a été repensé par P2210R2 , et le mécanisme lazy a été déplacé vers lazy_split_view .

Le délimiteur pattern ne devrait généralement pas être un littéral de chaîne ordinaire, car il considérera le terminateur nul comme une partie nécessaire du délimiteur ; par conséquent, il est conseillé d'utiliser un littéral std::string_view à la place.

Exemple

Exécuter ce code 
#include <iomanip>
#include <iostream>
#include <ranges>
#include <string_view>
int main()
{
    using std::operator""sv;
    constexpr auto words{"Hello^_^C++^_^20^_^!"sv};
    constexpr auto delim{"^_^"sv};
    for (const auto word : std::views::split(words, delim))
        // avec le constructeur de plage C++23 de string_view :
        std::cout << std::quoted(std::string_view(word)) << ' ';
    std::cout << '\n';
}

Sortie : 

"Hello" "C++" "20" "!"

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
P2210R2 C++20 l'ancien split_view était trop paresseux pour être facilement utilisé il a été repensé

Voir aussi

(C++20)
une view sur les sous-intervalles obtenus en divisant une autre view en utilisant un délimiteur
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view constituée de la séquence obtenue en aplatissant une view de range s
(modèle de classe) (objet adaptateur de gamme)