Namespaces
Variants

    Nicht propagierender Cache (C++20)

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    template< class T >
    requires std::is_object_v<T>
class /*non-propagating-cache*/;
    		(seit C++20)
    (nur zur Veranschaulichung*)

    Einige Range-Adaptoren wie ranges::join_view und ranges::lazy_split_view speichern bedingt einen Wert (z. B. einen Iterator), der mittels einer nur zur Veranschaulichung dienenden Klassenvorlage non-propagating-cache spezifiziert wird.

    Der Wrapper verhält sich genau wie std::optional<T>, mit den folgenden Ausnahmen:

    • er kopiert den Wert der Quelle nicht, wenn er kopierkonstruiert oder zugewiesen wird,
    • er setzt den Wert der Quelle zurück, wenn er von ihr wegverschoben wird,
    • er setzt seinen eigenen Wert zurück, wenn ihm ein Wert zugewiesen wird, und
    • er stellt zusätzlich eine Memberfunktionsvorlage bereit, die es einem input view ermöglicht, beim Iterieren vorübergehend Werte zwischenzuspeichern.

    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 durchgeführt.

    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)