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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bereichsbibliothek

Bereichszugriff begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata reserve_hint (C++26)   empty

Range-Konvertierungen std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Behandlung von hängenden Iteratoren dangling borrowed_iterator_t borrowed_subrange_t

Range-Primitive
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Range-Konzepte
range borrowed_range    common_range	sized_range viewable_range    view	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	approximately_sized_range (C++26) constant_range (C++23)

Ansichten
view_interface	subrange

Range-Fabriken
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Range-Adaptoren
views::all_tviews::all as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while common_viewviews::common views::counted to_input_viewviews::to_input (C++26)(C++26)	ref_view drop_viewviews::drop drop_while_viewviews::drop_while lazy_split_viewviews::lazy_split split_viewviews::split join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   concat_viewviews::concat (C++26)(C++26) cache_latest_viewviews::cache_latest (C++26)(C++26)	owning_view reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Range generators std::generator (C++23)

Range-Adaptor-Closure-Objekte range_adaptor_closure (C++23)

Range-Adaptor-Objekte

Hilfselemente
copyable-box movable-box (bis C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::concat_view

Memberfunktionen

concat_view::concat_view

concat_view::begin

concat_view::end

concat_view::size

Deduction Guides

Iterator

Memberfunktionen

concat_view::iterator::iterator

concat_view::iterator::operator*

concat_view::iterator::operator[]

concat_view::iterator::operator++ concat_view::iterator::operator++(int) concat_view::iterator::operator-- concat_view::iterator::operator--(int) concat_view::iterator::operator+= concat_view::iterator::operator-=

concat_view::iterator::satisfy concat_view::iterator::prev concat_view::iterator::advance-fwd concat_view::iterator::advance-bwd

Nicht-Member-Funktionen

operator==(concat_view::iterator) operator<(concat_view::iterator) operator>(concat_view::iterator) operator<=(concat_view::iterator) operator>=(concat_view::iterator) operator<=>(concat_view::iterator)

operator+(concat_view::iterator) operator-(concat_view::iterator)

iter_move(concat_view::iterator)

iter_swap(concat_view::iterator)

 

Definiert in der Header-Datei <ranges>
template< ranges::input_range... Views >     requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0) &&               /*concatable*/<Views...> class concat_view     : public ranges::view_interface<concat_view<Views...>>	(1)	(seit C++26)
namespace views {     inline constexpr /* unspecified */ concat = /* unspecified */; }	(2)	(seit C++26)
Aufruf-Signatur
template< ranges::viewable_range... Rs >     requires /* siehe unten */ constexpr ranges::view auto concat( Rs&&... rs );		(seit C++26)
Hilfstypaliasen
template< class... Rs > using /*concat-reference-t*/ =     ranges::common_reference_t<ranges::range_reference_t<Rs>...>;	(3)	(nur Exposition*)
template< class... Rs > using /*concat-value-t*/ = std::common_type_t<ranges::range_value_t<Rs>...>;	(4)	(nur Exposition*)
template< class... Rs > using /*concat-rvalue-reference-t*/ =     ranges::common_reference_t<ranges::range_rvalue_reference_t<Rs>...>;	(5)	(nur Exposition*)
Hilfskonzepte
template< class Ref, class RRef, class It > concept /*concat-indirectly-readable-impl*/ = /* siehe Beschreibung */;	(6)	(nur Exposition*)
template< class... Rs > concept /*concatable*/ = /* siehe Beschreibung */;	(7)	(nur Exposition*)

concat_view stellt eine view-Fabrik bereit, die eine beliebige Anzahl von Bereichen als Argumentliste entgegennimmt und eine Ansicht bietet, die vom ersten Element des ersten Bereichs beginnt, am letzten Element des letzten Bereichs endet und alle Bereichselemente dazwischen in der Reihenfolge ihrer Argumente verkettet, d. h. effektiv aneinanderreiht.

1) Die Klassenvorlage mit einem Vorlagenparameter, der ein nicht-leeres Paket von views ist, von denen jeder mindestens input_range modelliert und concatable (7) ist.

2) views::concat ist ein Customization Point Object.

Gegeben sei ein Paket von Ausdrücken exprs, der Ausdruck views::concat(exprs...) ist ausdrucksäquivalent zu

• views::all(exprs...) wenn exprs ein Paket mit nur einem Element ist, dessen Typ input_range modelliert,
• concat_view(exprs...) andernfalls.

3) Repräsentiert den Referenztyp. Eine zusätzliche Einschränkung ist erforderlich, um sicherzustellen, dass die ranges::range_reference_t jedes zugrundeliegenden Bereichs in eine ranges::common_reference_t konvertierbar ist.

4) Der iterator::value_type, der zusätzlich den value_type der zugrundeliegenden Bereiche berücksichtigt, um Fälle zu unterstützen, in denen die zugrundeliegenden Bereiche Proxy-Iteratoren haben.

5) Die Rvalue-Referenz, die auch Fälle korrekt unterstützt, in denen zugrundeliegende Iteratoren iter_move anpassen.

6) Definiert das indirectly-readable-Konzept für den iterator, damit concat_view input_range modellieren kann.

Äquivalent zu

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>> && ...);

wobei das exposition-only Konzept /*concat-indirectly-readable-impl*/ ist

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

7) Bestimmt, ob zwei oder mehr verschiedene Bereiche in eine Sequenz angepasst werden können, die selbst einen Bereich modelliert. Äquivalent zu

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 angepasste 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, das ein const Funktionsobjekt vom Typ Literal semiregular ist. Zu Erklärungszwecken wird die cv-unqualifizierte Version seines Typs als __concat_fn bezeichnet.

Alle Instanzen von __concat_fn sind gleich. Die Auswirkungen des Aufrufs verschiedener Instanzen des Typs __concat_fn mit denselben Argumenten sind äquivalent, unabhängig davon, ob der die Instanz bezeichnende Ausdruck ein lvalue oder rvalue ist und ob er const-qualifiziert ist oder nicht (eine volatile-qualifizierte Instanz muss jedoch nicht aufrufbar sein). Daher kann views::concat frei kopiert und seine Kopien können austauschbar verwendet werden.

Gegeben sei eine Menge von Typen Args.... Wenn std::declval<Args>()... die Anforderungen für Argumente an views::concat erfüllt, modelliert __concat_fn

• std::invocable<__concat_fn, Args...>,
• std::invocable<const __concat_fn, Args...>,
• std::invocable<__concat_fn&, Args...>, und
• std::invocable<const __concat_fn&, Args...>.
  

Andernfalls nimmt kein Funktionsaufrufoperator von __concat_fn an der Überladungsauflösung teil.

Datenmember

Mitglied	Beschreibung
std::tuple<Views...> views_	alle angepassten View-Objekte ((exposition-only member object*)

Memberfunktionen

(Konstruktor)	konstruiert eine concat_view (öffentliche Member-Funktion)
begin	gibt einen Iterator zum Anfang zurück (öffentliche Member-Funktion)
end	gibt einen Iterator oder Sentinel zum Ende zurück (öffentliche Member-Funktion)
size	gibt die Anzahl der Elemente zurück, nur bereitgestellt, wenn die zugrunde liegende (adaptierte) Range sized_range erfüllt (öffentliche Member-Funktion)
Geerbt von std::ranges::view_interface
empty	gibt zurück, ob die abgeleitete Ansicht leer ist, bereitgestellt nur, wenn sie sized_range oder forward_range erfüllt (public member function of std::ranges::view_interface<D>)
cbegin (C++23)	gibt einen konstanten Iterator zum Anfang des Bereichs zurück (public member function of std::ranges::view_interface<D>)
cend (C++23)	gibt ein Sentinel für den konstanten Iterator des Bereichs zurück (public member function of std::ranges::view_interface<D>)
operator bool	gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur, wenn ranges::empty darauf anwendbar ist (public member function of std::ranges::view_interface<D>)
front	gibt das erste Element in der abgeleiteten View zurück, bereitgestellt, wenn sie forward_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
back	gibt das letzte Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
operator[]	gibt das n-te Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie random_access_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)

Verschachtelte Klassen

Klassenname	Definition
iterator	der Iterator-Typ ((nur zur Veranschaulichung Exposition-only Member-Klassenschablone)*)

Hilfstemplates

Es gibt keine Spezialisierung von ranges::enable_borrowed_range für concat_view, da dies erfordern würde, dass die Iterator-Implementierung jederzeit eine Kopie aller Iteratoren und Sentinels aller zugrundeliegenden Bereiche enthält.

Hinweise

Kein Argument views::concat() ist ill-formed, 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).

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_ranges_concat	202403L	(C++26)	std::ranges::concat_view

Beispiel

Die Vorabversion kann auf Compiler Explorer eingesehen werden.

Führen Sie diesen Code aus

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

Ausgabe

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

• C++26 Standard (ISO/IEC 14882:2026)

• 26.7.18 Concat view [range.concat]

Siehe auch

ranges::join_viewviews::join (C++20)	ein view, der aus der Sequenz besteht, die durch Abflachung eines view von ranges gebildet wird (Klassen-Template) (Range-Adaptor-Objekt)
ranges::join_with_viewviews::join_with (C++23)	ein view, der aus der Sequenz besteht, die durch Abflachung eines Views von Ranges gebildet wird, mit dem Trennzeichen zwischen den Elementen (Klassen-Template) (Range-Adaptor-Objekt)
ranges::zip_viewviews::zip (C++23)	ein view, der aus Tupeln von Referenzen auf entsprechende Elemente der adaptierten Views besteht (Klassen-Template) (Customization Point Objekt)
ranges::cartesian_product_viewviews::cartesian_product (C++23)	eine view, die aus Tupeln von Ergebnissen besteht, welche durch das n-äre kartesische Produkt der angepassten Views berechnet werden (Klassenschablone) (Customization Point Objekt)