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

concat_view stellt eine view Factory bereit, die eine beliebige Anzahl von Bereichen als Argumentliste entgegennimmt und eine Ansicht bietet, die beim ersten Element des ersten Bereichs beginnt, beim letzten Element des letzten Bereichs endet und dabei alle Elemente der Bereiche in der Reihenfolge der Argumente zwischensequenziert, wodurch die Argumentbereiche effektiv verkettet oder aneinandergereiht werden.

template< class... Rs >
concept /*concat-indirectly-readable*/ = // nur zur Darstellung
    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 stets input_range und modelliert forward_range , bidirectional_range , random_access_range oder sized_range , falls jeder adaptierte view -Typ das entsprechende Konzept modelliert.

concat_view kann ein common_range sein, wenn der letzte zugrundeliegende 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