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

std::ranges::views::cache_latest, std::ranges::cache_latest_view - cppreference.com

From cppreference.com

Defined 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)	(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.

Nested types

Type	Definition
`CacheT` (private)	`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>>` (exposition-only member type*)

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*)

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 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<D>`) [edit]
cbegin (C++23)	returns a constant iterator to the beginning of the range (public member function of `std::ranges::view_interface<D>`) [edit]
cend (C++23)	returns a sentinel for the constant iterator of the range (public member function of `std::ranges::view_interface<D>`) [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<D>`) [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<D>`) [edit]
front	returns the first element in the derived view, provided if it satisfies `forward_range` (public member function of `std::ranges::view_interface<D>`) [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<D>`) [edit]
operator[]	returns the `n`^th element in the derived view, provided only if it satisfies `random_access_range` (public member function of `std::ranges::view_interface<D>`) [edit]

std::ranges::cache_latest_view::cache_latest_view

`cache_latest_view() requires std::default_initializable<V> = default;`	(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

`constexpr V base() const& requires std::copy_constructible<V>;`	(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

`constexpr auto size() requires ranges::sized_range<V>;`	(1)	(since C++26)
`constexpr auto size() const requires ranges::sized_range<const V>;`	(2)	(since C++26)

1,2) Equivalent to return ranges::size(base_);

Deduction guides

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

Nested classes

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

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`

Example

#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("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