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

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>>

namespace views {
    inline constexpr /* unspecified */ split = /* unspecified */;
}

template< ranges::viewable_range R, class Pattern >
    requires /* see below */
constexpr ranges::view auto split( R&& r, Pattern&& pattern );

template< class Pattern >
constexpr /* range adaptor closure */ split( Pattern&& pattern );

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

La range interne (ranges::range_reference_t<split_view>) est une 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 maintient la continuité de la sous-range, ce qui le rend approprié pour la division de chaînes.

Membres de données

Fonctions membres

Classes imbriquées

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

#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';
}

"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.

Voir aussi