Namespaces
Variants

Non-propagating cache (C++20)

From cppreference.net
C++
Ranges library
Range adaptors
Helper items
(until C++23) (C++23)
non-propagating-cache


template < class T >

requires std:: is_object_v < T >

class /*nicht-verbreitender-Cache*/ ;
(seit C++20)
( nur zur Darstellung* )

Einige Bereichsadapter wie ranges::join_view und ranges::lazy_split_view speichern bedingt Werte (z.B. einen Iterator), die in Form einer nur zur Darstellung dienenden Klassenvorlage non-propagating-cache definiert sind.

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

  • es kopiert nicht den Wert der Quelle, wenn es kopierkonstruiert oder zugewiesen wird,
  • es setzt den Wert der Quelle zurück, wenn es verschoben wird,
  • es setzt seinen eigenen Wert zurück, wenn ihm ein Wert zugewiesen wird, und
  • es bietet zusätzlich eine Member-Funktionsvorlage, um einer Eingabeansicht zu ermöglichen, Werte temporär zwischenzuspeichern, während sie iteriert wird.

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

Inhaltsverzeichnis

Template-Parameter

T - der Typ des enthaltenen Werts, 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 löscht den Cache von other .

Kopier- und Verschiebezuweisungsoperatoren

constexpr /*non-propagating-cache*/ &

operator = ( const /*non-propagating-cache*/ & other ) noexcept
{
if ( std:: addressof ( other ) ! = this )
reset ( ) ;
return * this ;

}
(1) (since C++20)
constexpr /*non-propagating-cache*/ &

operator = ( /*non-propagating-cache*/ && other ) noexcept
{
reset ( ) ;
other. reset ( ) ;
return * this ;

}
(2) (since C++20)
1) Der Kopierzuweisungsoperator löscht den Cache von * this .
2) Der Verschiebezuweisungsoperator löscht 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 zur Darstellung* )

Initialisiert den enthaltenen Wert durch Direktinitialisierung (aber nicht Direktlisteninitialisierung) mit * i . Falls * this vor dem Aufruf bereits einen Wert enthielt, wird reset ( ) aufgerufen.

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

Das Programm ist fehlerhaft, es sei denn, die Deklaration T t ( * i ) ; ist für eine erfundene Variable t wohlgeformt. Wenn * i ein Prvalue von möglicherweise cv-qualifiziertem T ist, muss es nicht beweglich sein.

Mitglieder identisch mit std:: optional

Elementfunktionen

konstruiert das optional -Objekt
(öffentliche Elementfunktion von std::optional<T> )
zerstört den enthaltenen Wert, falls vorhanden
(öffentliche Elementfunktion von std::optional<T> )
weist Inhalte zu
(öffentliche Elementfunktion von std::optional<T> )
Beobachter
greift auf den enthaltenen Wert zu
(öffentliche Elementfunktion von std::optional<T> )
prüft, ob das Objekt einen Wert enthält
(öffentliche Elementfunktion von std::optional<T> )
Modifikatoren
zerstört jeden enthaltenen Wert
(öffentliche Elementfunktion von std::optional<T> )
konstruiert den enthaltenen Wert direkt
(öffentliche Elementfunktion von std::optional<T> )

Hinweise

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

Siehe auch

(C++20)
eine view bestehend aus der Sequenz, die durch Glätten einer view von range s erhalten wird
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine view bestehend aus der Sequenz, die durch Glätten einer View von Ranges erhalten wird, mit Trennzeichen zwischen Elementen
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view über die Subranges, die durch Aufteilen einer anderen view mit einem Trennzeichen erhalten werden
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view über die Subranges, die durch Aufteilen einer anderen view mit einem Trennzeichen erhalten werden
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine Range von view s die N -große nicht überlappende aufeinanderfolgende Teile der Elemente einer anderen view sind
(Klassentemplate) (Range-Adapter-Objekt)