std::ranges:: views:: concat, std::ranges:: concat_view

concat_view présente une view factory qui prend un nombre arbitraire de plages comme liste d'arguments, et fournit une vue qui commence au premier élément de la première plage, se termine au dernier élément de la dernière plage, avec tous les éléments des plages séquencés entre eux respectivement dans l'ordre donné dans les arguments, concaténant effectivement, ou chaînant ensemble les plages d'arguments.

template< class... Rs >
concept /*concat-indirectly-readable*/ = // exposition uniquement
    std::common_reference_with</*concat-reference-t*/<Rs...>&&,
                               /*concat-value-t*/<Rs...>&> &&
    std::common_reference_with</*concat-reference-t*/<Rs...>&&,
                               /*concat-rvalue-reference-t*/<Rs...>&&> &&
    std::common_reference_with</*concat-rvalue-reference-t*/<Rs...>&&,
                               /*concat-value-t*/<Rs...> const&> &&
    (/*concat-indirectly-readable-impl*/</*concat-reference-t*/<Rs...>,
                                         /*concat-rvalue-reference-t*/<Rs...>,
                                         ranges::iterator_t<Rs>> && ...);

template< class Ref, class RRef, class It >
concept /*concat-indirectly-readable-impl*/ = // exposition only
    requires(const It it) {
        { *it } -> std::convertible_to<Ref>;
        { ranges::iter_move(it)} -> std::convertible_to<RRef>;
    };

template< class... Rs >
concept /*concatable*/ = requires { // exposition only
        typename /*concat-reference-t*/<Rs...>;
        typename /*concat-value-t*/<Rs...>;
        typename /*concat-rvalue-reference-t*/<Rs...>;
    } && /*concat-indirectly-readable*/<Rs...>;

concat_view modélise toujours input_range , et modélise forward_range , bidirectional_range , random_access_range , ou sized_range si chaque type de view adapté modélise le concept correspondant.

concat_view peut être une common_range si la dernière plage sous-jacente modélise common_range .

Objets de point de personnalisation

Le nom views::concat désigne un objet de point de personnalisation , qui est un objet fonction constant d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Membres de données

Fonctions membres

Guides de déduction

Classes imbriquées

Modèles d'assistance

Il n'y a pas de spécialisation de ranges:: enable_borrowed_range pour concat_view , car cela nécessiterait que l'implémentation de l'itérateur contienne une copie de tous les itérateurs et sentinelles de toutes les plages sous-jacentes à tout moment.

Notes

Aucun argument views :: concat ( ) est mal formé, car il n'existe aucune manière raisonnable de déterminer un type d'élément T . Un seul argument views :: concat ( r ) est une expression équivalente à views:: all ( r ) .

Exemple

#include <cassert>
#include <list>
#include <print>
#include <ranges>
#include <vector>
int main()
{
    std::vector<int> v0{1, 2, 3}, v1{4, 5};
    int a[]{6, 7};
    int i{8};
    auto ie{std::views::single(i)};
    auto con = std::views::concat(v0, v1, a, ie);
    assert(con.size() == v0.size() + v1.size() + std::size(a) + ie.size());
    std::println("con.size(): {}", con.size());
    std::println("con: {}", con);
    con[6] = 42; // con is random_access_range, operator[] returns a reference
    assert(a[1] == 42); // a[1] was modified via con[6]
    std::println("con: {}", con);
    std::list<int> l{7, 8}; // list is bidirectional range
    auto cat = std::views::concat(v0, l);
    std::println("cat: {}", cat);
    // cat[0] = 13; // compile-time error: cat is bidirectional => no operator[]
}

con.size(): 8
con: [1, 2, 3, 4, 5, 6, 7, 8]
con: [1, 2, 3, 4, 5, 6, 42, 8]
cat: [1, 2, 3, 7, 8]

Références

Voir aussi