Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::cache_latest_view
Member functions
Deduction guides
Iterator
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
Definiert im 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 /* nicht spezifiziert */ cache_latest = /* nicht spezifiziert */ ;

}
(2) (seit C++26)
Aufrufsignatur
template < ranges:: viewable_range R >

requires /* siehe unten */

constexpr ranges:: view auto cache_latest ( R && r ) ;
(seit C++26)
1) Ein Bereichsadapter, der das zuletzt abgerufene Element seines zugrunde liegenden view zwischenspeichert, sodass das Element bei wiederholtem Zugriff nicht erneut berechnet werden muss.
2) RangeAdaptorObject . Der Ausdruck views :: cache_latest ( e ) ist ausdrucksäquivalent zu cache_latest_view ( e ) für jeden geeigneten Subausdruck e .

cache_latest_view ist ein input_range -only, das niemals borrowed_range oder common_range modelliert.

Inhaltsverzeichnis

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 std::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> )
ruft die Adresse der Daten der abgeleiteten Ansicht ab, 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 n te 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