std::ranges::views::cache_latest, std::ranges::cache_latest_view - cppreference.com (original) (raw)

std::ranges::cache_latest_view

Defined in header
template< ranges::input_range V > requires ranges::view<V> class cache_latest_view : public ranges::view_interface<cache_latest_view<V>> (1) (since C++26)
namespace views { inline constexpr /* unspecified */ cache_latest = /* unspecified */; } (2) (since C++26)
Call signature
template< ranges::viewable_range R > requires /* see below */ constexpr ranges::view auto cache_latest( R&& r ); (since C++26)
  1. A range adaptor that caches the last-accessed element of its underlying view so that the element does not have to be recomputed on repeated access.

cache_latest_view is an input_range-only that never models borrowed_range or common_range.

Contents

[edit] Nested types

[edit] Data members

Member Description
V base_ (private) the underlying view(exposition-only member object*)
non-propagating-cache<CacheT> cache_ (private) an object that caches the result of the last indirection of the current iterator(exposition-only member object*)

[edit] Member functions

(constructor) constructs a cache_latest_view (public member function)
base returns a copy of the underlying (adapted) view (public member function)
begin returns an iterator to the beginning (public member function)
end returns an iterator or a sentinel to the end (public member function)
size returns the number of elements. Provided only if the underlying (adapted) range satisfies sized_range. (public member function)
Inherited from std::ranges::view_interface
empty returns whether the derived view is empty, provided only if it satisfies sized_range or forward_range (public member function of std::ranges::view_interface) [edit]
cbegin(C++23) returns a constant iterator to the beginning of the range (public member function of std::ranges::view_interface) [edit]
cend(C++23) returns a sentinel for the constant iterator of the range (public member function of std::ranges::view_interface) [edit]
operator bool returns whether the derived view is not empty, provided only if ranges::empty is applicable to it (public member function of std::ranges::view_interface) [edit]
data gets the address of derived view's data, provided only if its iterator type satisfies contiguous_iterator (public member function of std::ranges::view_interface) [edit]
front returns the first element in the derived view, provided if it satisfies forward_range (public member function of std::ranges::view_interface) [edit]
back returns the last element in the derived view, provided only if it satisfies bidirectional_range and common_range (public member function of std::ranges::view_interface) [edit]
operator[] returns the nth element in the derived view, provided only if it satisfies random_access_range (public member function of std::ranges::view_interface) [edit]

std::ranges::cache_latest_view::cache_latest_view

| | (1) | (since C++26) | | | ------------------------------------------------- | ------------- | ------------- | | constexpr explicit cache_latest_view( V base ); | (2) | (since C++26) |

  1. Value-initializes _base_ via its default member initializer (= V()).

  2. Initializes _base_ with std::move(base).

Parameters

std::ranges::cache_latest_view::base

| | (1) | (since C++26) | | | ---------------------- | ------------- | ------------- | | constexpr V base() &&; | (2) | (since C++26) |

  1. Copy-constructs the result from the underlying view. Equivalent to return base_;.

  2. Move-constructs the result from the underlying view. Equivalent to return std::move(base_);.

std::ranges::cache_latest_view::begin

| constexpr auto begin(); | | (since C++26) | | ----------------------- | | ------------- |

Equivalent to return /*iterator*/(*this);.

std::ranges::cache_latest_view::end

| constexpr auto end(); | | (since C++26) | | --------------------- | | ------------- |

Equivalent to return /*sentinel*/(*this);.

std::ranges::cache_latest_view::size

[edit] Deduction guides

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

[edit] Nested classes

| | the iterator type(exposition-only member class template*) | | ------------------------------------------------------------- | | | the sentinel type(exposition-only member class template*) |

[edit] Notes

cache_latest_view is useful if the computation of the element to produce is expensive.

Feature-test macro Value Std Feature
__cpp_lib_ranges_cache_latest 202411L (C++26) std::ranges::cache_latest_view

[edit] Example

#include #include #include   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("Without caching latest (note recalculations):"); auto even_squares = v | std::views::transform(square) | std::views::filter(is_even); print(even_squares);   std::println("With caching latest:"); auto fast_even_squares = v | std::views::transform(square) | std::views::cache_latest | std::views::filter(is_even); print(fast_even_squares); }

Output:

Without caching latest (note recalculations): 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 With caching latest: transform: 1 filter: 1 transform: 2 filter: 4 Got: 4 transform: 3 filter: 9 transform: 4 filter: 16 Got: 16 transform: 5 filter: 25