std::ranges::view, std::ranges::enable_view, std::ranges::view_base

 

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

 

Definiert in der Header-Datei <ranges>
template<class T> concept view = ranges::range<T> && std::movable<T> && ranges::enable_view<T>;	(1)	(seit C++20)
template<class T> constexpr bool enable_view =     std::derived_from<T, view_base> || /*is-derived-from-view-interface*/<T>;	(2)	(seit C++20)
struct view_base { };	(3)	(seit C++20)

1) Das view-Konzept spezifiziert die Anforderungen an einen range-Typ, der geeignete semantische Eigenschaften für die Verwendung in Pipelines von Range-Adaptoren aufweist.

2) Das Variablen-Template enable_view wird verwendet, um anzuzeigen, ob ein range ein view ist. /*is-derived-from-view-interface*/<T> ist true genau dann, wenn T genau eine öffentliche Basisklasse ranges::view_interface<U> für einen Typ U hat und T keine Basisklassen vom Typ ranges::view_interface<V> für einen anderen Typ V hat.
Benutzer können enable_view für cv-unqualifizierte, vom Benutzer definierte Typen, die view modellieren, zu true und für Typen, die dies nicht tun, zu false spezialisieren. Solche Spezialisierungen müssen in konstanten Ausdrücken verwendbar sein und vom Typ const bool sein.

3) Die Ableitung von view_base ermöglicht es range-Typen, view zu modellieren.

Semantische Anforderungen

1) T modelliert view nur, wenn

• die Move-Konstruktion von T konstante Zeitkomplexität hat, und
• wenn \(\scriptsize N\)N Kopien und/oder Moves von einem T-Objekt durchgeführt werden, das \(\scriptsize M\)M Elemente enthält, dann haben diese \(\scriptsize N\)N Objekte eine Zerstörungszeitkomplexität von \(\scriptsize \mathcal{O}{(N+M)}\)𝓞(N+M) (was impliziert, dass ein nach einem Move verändertes view-Objekt eine Zerstörungszeitkomplexität von \(\scriptsize \mathcal{O}{(1)}\)𝓞(1) hat), und
• entweder std::copy_constructible<T> false ist, oder die Kopierkonstruktion von T konstante Zeitkomplexität hat, und
• entweder std::copyable<T> false ist, oder die Kopierzuweisung von T keine höhere Zeitkomplexität hat als Zerstörung gefolgt von Kopierkonstruktion.

Spezialisierungen

Spezialisierungen von enable_view für alle Spezialisierungen der folgenden Standard-Templates sind als true definiert

• std::basic_string_view
• std::span

std::optional

(seit C++26)

Anmerkungen

Beispiele für view-Typen sind

• Ein range-Typ, der ein Iteratorpaar umschließt, z. B. std::ranges::subrange<I>.
• Ein range-Typ, der seine Elemente über std::shared_ptr hält und den Besitz mit allen seinen Kopien teilt.
• Ein range-Typ, der seine Elemente bei Bedarf generiert, z. B. std::ranges::iota_view.

Ein kopierbarer Container wie std::vector<std::string> erfüllt im Allgemeinen nicht die semantischen Anforderungen von view, da das Kopieren des Containers alle Elemente kopiert, was nicht in konstanter Zeit erfolgen kann.

Obwohl Views ursprünglich als kostengünstig kopierbare und nicht besitzende Ranges beschrieben wurden, muss ein Typ nicht kopierbar oder nicht besitzend sein, um view zu modellieren. Er muss jedoch immer noch kostengünstig zu kopieren (falls er kopierbar ist), zu verschieben, zuzuweisen und zu zerstören sein, damit Range-Adaptoren keine unerwartete Komplexität aufweisen.

Standardmäßig wird ein Typ, der movable und range modelliert, als View betrachtet, wenn er öffentlich und eindeutig von view_base abgeleitet ist oder von genau einer Spezialisierung von std::ranges::view_interface.

Beispiel

Ein minimaler View.

#include <ranges>
 
struct ArchetypalView : std::ranges::view_interface<ArchetypalView>
{
    int* begin();
    int* end();
};
 
static_assert(std::ranges::view<ArchetypalView>);

Defect Reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
P2325R3	C++20	view erforderte default_initializable	erfordert nicht
LWG 3549	C++20	enable_view erkannte keine Vererbung von view_interface	erkennt
P2415R2	C++20	die Einschränkung der Zeitkomplexität der Zerstörung war zu streng	gelockert