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

template< ranges::input_range... Views >
    requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0) &&
              /*concatable*/<Views...>
class concat_view
    : public ranges::view_interface<concat_view<Views...>>

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

template< ranges::viewable_range... Rs >
    requires /* see below */
constexpr ranges::view auto concat( Rs&&... rs );

template< class... Rs >
using /*concat-reference-t*/ =
    ranges::common_reference_t<ranges::range_reference_t<Rs>...>;

template< class... Rs >
using /*concat-value-t*/ = std::common_type_t<ranges::range_value_t<Rs>...>;

template< class... Rs >
using /*concat-rvalue-reference-t*/ =
    ranges::common_reference_t<ranges::range_rvalue_reference_t<Rs>...>;

template< class Ref, class RRef, class It >
concept /*concat-indirectly-readable-impl*/ = /* see description */;

template< class... Rs >
concept /*concatable*/ = /* see description */;

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

template< class... Rs >
concept /*concat-indirectly-readable*/ = // exposition only
    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 vue adapté modélise le concept correspondant.

concat_view peut être common_range si la dernière séquence 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