Nicht-weitergebender Cache (C++20)

 

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

 

template< class T >     requires std::is_object_v<T> class /*non-propagating-cache*/;		(seit C++20) (nur Exposition*)

Einige Bereichsadapter wie ranges::join_view und ranges::lazy_split_view speichern bedingt Werte (z.B. einen Iterator), die in Bezug auf eine exposition-only-Klassenvorlage non-propagating-cache spezifiziert sind.

Der Wrapper verhält sich exakt wie std::optional<T>, außer dass

• er beim Kopieren oder Zuweisen des Quellobjekts dessen Wert nicht kopiert,
• er beim Verschieben des Quellobjekts dessen Wert zurücksetzt,
• er beim Zuweisen seinen eigenen Wert zurücksetzt und
• er zusätzlich eine Member-Funktionstemplate bereitstellt, um einem Eingabebereich das temporäre Caching von Werten während der Iteration zu ermöglichen.

Der Wrapper kapselt einen Cache, der einen Wert enthält. Das Leeren des Caches ist eine Operation, die dem Zurücksetzen eines enthaltenen Wertes entspricht. Eine solche Operation wird beim Kopieren oder Verschieben eines Wrappers ausgeführt.

Vorlagenparameter

T

-

der Typ des enthaltenen Wertes, muss ein Objekttyp sein

Memberfunktionen

Kopier- und Move-Konstruktoren

constexpr /*non-propagating-cache*/     ( const /*non-propagating-cache*/& ) noexcept {}	(1)	(seit C++20)
constexpr /*non-propagating-cache*/     ( /*non-propagating-cache*/&& other ) noexcept { other.reset(); }	(2)	(seit C++20)

1) Der Kopierkonstruktor hat keine Auswirkung.

2) Der Move-Konstruktor leert den Cache von other.

Kopier- und Move-Zuweisungsoperatoren

constexpr /*non-propagating-cache*/&     operator=( const /*non-propagating-cache*/& other ) noexcept {     if (std::addressof(other) != this)         reset();     return *this; }	(1)	(seit C++20)
constexpr /*non-propagating-cache*/&     operator=( /*non-propagating-cache*/&& other ) noexcept {     reset();     other.reset();     return *this; }	(2)	(seit C++20)

1) Der Kopierzuweisungsoperator leert den Cache von *this.

2) Der Move-Zuweisungsoperator leert die Caches von sowohl *this als auch other.

non-propagating-cache<T>::emplace-deref

template< class I > constexpr T& /*emplace-deref*/( const I& i );		(seit C++20) (nur Exposition*)

Initialisiert den enthaltenen Wert durch direkte Initialisierung (aber nicht durch direkte Listeninitialisierung) mit *i. Wenn *this vor dem Aufruf bereits einen Wert enthält, wird reset() aufgerufen.

Gibt eine Referenz auf den neu enthaltenen Wert zurück.

Das Programm ist schlecht geformt, es sei denn, die Deklaration T t(*i); ist für eine erfundene Variable t wohlgeformt. Wenn *i ein Prvalue eines möglicherweise cv-qualifizierten T ist, ist es nicht erforderlich, verschiebbar zu sein.

Mitglieder identisch mit std::optional

Memberfunktionen

(Konstruktor)	konstruiert das optional-Objekt (public member function of std::optional<T>)
(Destruktor)	zerstört den enthaltenen Wert, falls vorhanden (public member function of std::optional<T>)
operator=	weist Inhalte zu (public member function of std::optional<T>)
Observer
operator->operator*	greift auf den enthaltenen Wert zu (public member function of std::optional<T>)
operator boolhas_value	prüft, ob das Objekt einen Wert enthält (public member function of std::optional<T>)
Modifizierer
reset	zerstört jeden enthaltenen Wert (public member function of std::optional<T>)
emplace	konstruiert den enthaltenen Wert in-place (public member function of std::optional<T>)

Hinweise

non-propagating-cache wird in Implementierungen verwendet, um das Ergebnis von begin() zu cachen und so eine amortisierte konstante Zeitkomplexität der Methode zu gewährleisten.

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::split_viewviews::split (C++20)	ein view über die Unterbereiche, die durch Aufteilen eines anderen view mit einem Trennzeichen gebildet werden (Klassen-Template) (Range-Adaptor-Objekt)
ranges::lazy_split_viewviews::lazy_split (C++20)	ein view über die Unterbereiche, die durch Aufteilen eines anderen view mit einem Trennzeichen gebildet werden (Klassen-Template) (Range-Adaptor-Objekt)
ranges::chunk_viewviews::chunk (C++23)	eine Reihe von views, die N-elementige, nicht überlappende, aufeinanderfolgende Blöcke von Elementen einer anderen view sind (Klassenschablone) (Range-Adaptor-Objekt)