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
Défini dans l'en-tête <ranges>
template < ranges:: input_range V >

requires ranges:: view < V >
class cache_latest_view

: public ranges:: view_interface < cache_latest_view < V >>
(1) (depuis C++26)
namespace views {

inline constexpr /* non spécifié */ cache_latest = /* non spécifié */ ;

}
(2) (depuis C++26)
Signature d'appel
template < ranges:: viewable_range R >

requires /* voir ci-dessous */

constexpr ranges:: view auto cache_latest ( R && r ) ;
(depuis C++26)
1) Un adaptateur de gamme qui met en cache le dernier élément accédé de sa view sous-jacente afin que l'élément n'ait pas besoin d'être recalculé lors d'accès répétés.
2) RangeAdaptorObject . L'expression views :: cache_latest ( e ) est équivalente en expression à cache_latest_view ( e ) pour toute sous-expression appropriée e .

cache_latest_view est un input_range uniquement qui ne modélise jamais borrowed_range ni common_range .

Table des matières

Types imbriqués

Type Définition
CacheT (privé) 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 >>
( type membre d'exposition uniquement* )

Membres de données

Membre Description
V base_ (privé) la vue sous-jacente
( objet membre d'exposition uniquement* )
non-propagating-cache < CacheT > cache_ (privé) un objet qui met en cache le résultat de la dernière indirection de l'itérateur courant
( objet membre d'exposition uniquement* )

Fonctions membres

construit un cache_latest_view
(fonction membre publique)
retourne une copie de la vue sous-jacente (adaptée)
(fonction membre publique)
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur ou un sentinelle vers la fin
(fonction membre publique)
retourne le nombre d'éléments. Fourni uniquement si la plage sous-jacente (adaptée) satisfait sized_range .
(fonction membre publique)
Hérité de std::ranges::view_interface
indique si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un itérateur constant vers le début de la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
indique si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
obtient l'adresse des données de la vue dérivée, fourni uniquement si son type d'itérateur satisfait contiguous_iterator
(fonction membre publique de std::ranges::view_interface<D> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le n ème élément de la vue dérivée, fourni uniquement si elle satisfait random_access_range
(fonction membre publique de std::ranges::view_interface<D> )

std::ranges::cache_latest_view:: cache_latest_view

cache_latest_view ( ) requires std:: default_initializable < V > = default ;
(1) (depuis C++26)
constexpr explicit cache_latest_view ( V base ) ;
(2) (depuis C++26)
1) Initialise par valeur base_ via son initialiseur de membre par défaut ( = V ( ) ).
2) Initialise base_ avec std :: move ( base ) .

Paramètres

base - une vue

std::ranges::cache_latest_view:: base

constexpr V base ( ) const & requires std:: copy_constructible < V > ;
(1) (depuis C++26)
constexpr V base ( ) && ;
(2) (depuis C++26)
1) Construit par copie le résultat à partir de la vue sous-jacente. Équivalent à return base_ ; .
2) Construit par déplacement le résultat à partir de la vue sous-jacente. Équivalent à return std :: move ( base_ ) ; .

std::ranges::cache_latest_view:: begin

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

Équivalent à return /*iterator*/ ( * this ) ; .

std::ranges::cache_latest_view:: end

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

Équivalent à return /*sentinel*/ ( * this ) ; .

std::ranges::cache_latest_view:: size

constexpr auto size ( ) requires ranges:: sized_range < V > ;
(1) (depuis C++26)
constexpr auto size ( ) const requires ranges:: sized_range < const V > ;
(2) (depuis C++26)
1,2) Équivalent à return ranges:: size ( base_ ) ;

Guides de déduction

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

Classes imbriquées

le type d'itérateur
( classe membre template d'exposition uniquement* )
le type de sentinelle
( classe membre template d'exposition uniquement* )

Notes

cache_latest_view est utile si le calcul de l'élément à produire est coûteux.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_ranges_cache_latest 202411L (C++26) std::ranges::cache_latest_view

Exemple

Exécuter ce code 
#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("Sans mise en cache (notez les recalculs) :");
    auto even_squares = v
        | std::views::transform(square)
        | std::views::filter(is_even);
    print(even_squares);
    std::println("Avec mise en cache :");
    auto fast_even_squares = v
        | std::views::transform(square)
        | std::views::cache_latest
        | std::views::filter(is_even);
    print(fast_even_squares);
}

Sortie : 

Sans mise en cache (notez les recalculs) :
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 
Avec mise en cache :
transform: 1 filter: 1 transform: 2 filter: 4 Got: 4
transform: 3 filter: 9 transform: 4 filter: 16 Got: 16
transform: 5 filter: 25