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 stellt eine Ansichtsfabrik bereit, die eine beliebige Anzahl von Bereichen als Argumentliste nimmt und eine Ansicht bereitstellt, die mit dem ersten Element des ersten Bereichs beginnt, mit dem letzten Element des letzten Bereichs endet und alle Bereichselemente dazwischen in der Reihenfolge der Argumente anordnet, wodurch die Argumentbereiche effektiv konkateniert (aneinandergereiht) werden.

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 modelliert immer input_range und modelliert forward_range, bidirectional_range, random_access_range oder sized_range, wenn jeder adaptierte Ansichtstyp das entsprechende Konzept modelliert.

concat_view kann common_range sein, wenn der letzte zugrunde liegende Bereich common_range modelliert.

Customization Point Objects

Der Name views::concat bezeichnet ein Customization Point Object , welches ein konstantes Function Object eines Literal semiregular -Klassentyps ist. Weitere Details finden Sie unter CustomizationPointObject .

Datenmitglieder

Memberfunktionen

Deduktionshilfen

Geschachtelte Klassen

Hilfsvorlagen

Es gibt keine Spezialisierung von ranges:: enable_borrowed_range für concat_view , da dies erfordern würde, dass die Iterator-Implementierung zu jeder Zeit eine Kopie aller Iteratoren und Sentinel-Objekte aller zugrundeliegenden Bereiche enthalten müsste.

Hinweise

Kein Argument views :: concat ( ) ist fehlerhaft, da es keine sinnvolle Möglichkeit gibt, einen Elementtyp T zu bestimmen. Ein einzelnes Argument views :: concat ( r ) ist ausdrucksäquivalent zu views:: all ( r ) .

Beispiel

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

Referenzen

Siehe auch