Namespaces
Variants

    std::ranges::views::cache_latest, std::ranges::cache_latest_view

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsadapter
     
    std::ranges::cache_latest_view
    Mitgliedsfunktionen
    Ableitungsrichtlinien
    Iterator
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    Definiert in Header <ranges> 
    template< ranges::input_range V >
    requires ranges::view<V>
class cache_latest_view
    : public ranges::view_interface<cache_latest_view<V>>
    		(1) (seit C++26) 
    namespace views {
    inline constexpr /* unspecified */ cache_latest = /* unspecified */;
}
    		(2) (seit C++26)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto cache_latest( R&& r );
    		(seit C++26)
    1) Ein Bereichsadapter, der das zuletzt zugegriffene Element seiner zugrunde liegenden Ansicht sodass das Element bei wiederholtem Zugriff nicht neu berechnet werden muss.
    2) RangeAdaptorObject. Der Ausdruck views::cache_latest(e) ist expression-equivalent zu cache_latest_view(e) für jeden geeigneten Unterausdruck e.

    cache_latest_view ist eine input_range-nur, die niemals borrowed_range oder common_range modelliert.

    Geschachtelte Typen

    Typ Definition
    CacheT (privat) std:: conditional_t < std:: is_reference_v < ranges:: range_reference_t < V >> ,
    std:: add_pointer_t < ranges:: range_reference_t < V >> ,
    ranges:: range_reference_t < V >>
    ( Nur zur Darstellung verwendeter Member-Typ* )

    Datenmitglieder

    Member Beschreibung
    V base_ (privat) die zugrundeliegende Ansicht
    ( Nur-Darstellungs-Memberobjekt* )
    non-propagating-cache < CacheT > cache_ (privat) ein Objekt, das das Ergebnis der letzten Indirektion des aktuellen Iterators zwischenspeichert
    ( Nur-Darstellungs-Memberobjekt* )

    Memberfunktionen

    		konstruiert eine cache_latest_view
    (öffentliche Elementfunktion)
    		gibt eine Kopie der zugrunde liegenden (angepassten) Ansicht zurück
    (öffentliche Elementfunktion)
    		gibt einen Iterator zum Anfang zurück
    (öffentliche Elementfunktion)
    		gibt einen Iterator oder einen Sentinel zum Ende zurück
    (öffentliche Elementfunktion)
    		gibt die Anzahl der Elemente zurück. Nur bereitgestellt, wenn der zugrunde liegende (angepasste) Bereich sized_range erfüllt.
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur bereitgestellt, wenn sie sized_range oder forward_range
    erfüllt(öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Anfang des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Ansicht nicht leer ist, nur bereitgestellt, wenn ranges::empty darauf anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		ermittelt die Adresse der Daten der abgeleiteten Ansicht, nur bereitgestellt, wenn ihr Iteratortyp contiguous_iterator
    erfüllt(öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Ansicht zurück, bereitgestellt, wenn sie forward_range
    erfüllt(öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Ansicht zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range
    erfüllt(öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das nte Element in der abgeleiteten Ansicht zurück, nur bereitgestellt, wenn sie random_access_range
    erfüllt(öffentliche Elementfunktion von std::ranges::view_interface<D>)

    std::ranges::cache_latest_view:: cache_latest_view

    cache_latest_view ( ) requires std:: default_initializable < V > = default ;
    		(1) (seit C++26)
    constexpr explicit cache_latest_view ( V base ) ;
    		(2) (seit C++26)
    1) Wertinitialisiert base_ über seinen Standard-Memberinitialisierer ( = V ( ) ).
    2) Initialisiert base_ mit std :: move ( base ) .

    Parameter

    base - eine View

    std::ranges::cache_latest_view:: base

    constexpr V base ( ) const & requires std:: copy_constructible < V > ;
    		(1) (seit C++26)
    constexpr V base ( ) && ;
    		(2) (seit C++26)
    1) Kopiert das Ergebnis aus der zugrundeliegenden Ansicht. Entspricht return base_ ; .
    2) Verschiebt das Ergebnis aus der zugrundeliegenden Ansicht. Entspricht return std :: move ( base_ ) ; .

    std::ranges::cache_latest_view:: begin

    constexpr auto begin ( ) ;
    		(seit C++26)

    Entspricht return /*iterator*/ ( * this ) ; .

    std::ranges::cache_latest_view:: end

    constexpr auto end ( ) ;
    		(seit C++26)

    Entspricht return /*sentinel*/ ( * this ) ; .

    std::ranges::cache_latest_view:: size

    constexpr auto size ( ) requires ranges:: sized_range < V > ;
    		(1) (seit C++26)
    constexpr auto size ( ) const requires ranges:: sized_range < const V > ;
    		(2) (seit C++26)
    1,2) Entspricht return ranges:: size ( base_ ) ;

    Deduktionsanleitungen

    template < class R >
    cache_latest_view ( R && ) - > cache_latest_view < views:: all_t < R >> ;
    		(seit C++26)

    Geschachtelte Klassen

    		der Iteratortyp
    ( Nur zur Darstellung verwendete Member-Klassenvorlage* )
    		der Sentinel-Typ
    ( Nur zur Darstellung verwendete Member-Klassenvorlage* )

    Hinweise

    cache_latest_view ist nützlich, wenn die Berechnung des zu erzeugenden Elements aufwändig ist.

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_cache_latest 202411L (C++26) std::ranges::cache_latest_view

    Beispiel

    Diesen Code ausführen 
    #include <algorithm>
#include <print>
#include <ranges>
int main()
{
    const auto v = {1, 2, 3, 4, 5};
    auto square = [](int i)
    {
        std::print("transform: {} ", i);
        return i * i;
    };
    auto is_even = [](int i)
    {
        std::print("filter: {} ", i);
        return i % 2 == 0;
    };
    auto print = [](auto v)
    {
        std::ranges::for_each(v, [](int i){ std::println("Got: {}", i); });
        std::println();
    };
    std::println("Ohne Zwischenspeicherung (beachten Sie die Neuberechnungen):");
    auto even_squares = v
        | std::views::transform(square)
        | std::views::filter(is_even);
    print(even_squares);
    std::println("Mit Zwischenspeicherung:");
    auto fast_even_squares = v
        | std::views::transform(square)
        | std::views::cache_latest
        | std::views::filter(is_even);
    print(fast_even_squares);
}

    Ausgabe: 

    Ohne Zwischenspeicherung (beachten Sie die Neuberechnungen):
transform: 1 filter: 1 transform: 2 filter: 4 transform: 2 Got: 4
transform: 3 filter: 9 transform: 4 filter: 16 transform: 4 Got: 16
transform: 5 filter: 25 
Mit Zwischenspeicherung:
transform: 1 filter: 1 transform: 2 filter: 4 Got: 4
transform: 3 filter: 9 transform: 4 filter: 16 Got: 16
transform: 5 filter: 25