std::ranges::views::cache_latest, std::ranges::cache_latest_view
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.2) RangeAdaptorObject. The expression
views::cache_latest(e) is expression-equivalent to cache_latest_view(e) for any suitable subexpression e.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
constructs a cache_latest_view (public member function) | |
| returns a copy of the underlying (adapted) view (public member function) | |
| returns an iterator to the beginning (public member function) | |
| returns an iterator or a sentinel to the end (public member function) | |
returns the number of elements. Provided only if the underlying (adapted) range satisfies sized_range. (public member function) | |
Inherited from ranges::view_interface | |
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>)
| |
(C++23) |
returns a constant iterator to the beginning of the range (public member function of std::ranges::view_interface<D>)
|
(C++23) |
returns a sentinel for the constant iterator of the range (public member function of std::ranges::view_interface<D>)
|
| 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>)
| |
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>)
| |
returns the first element in the derived view, provided if it satisfies forward_range (public member function of std::ranges::view_interface<D>)
| |
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>)
| |
returns the nth element in the derived view, provided only if it satisfies random_access_range (public member function of std::ranges::view_interface<D>)
| |
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
| base | - | a view |
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
Run this 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("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
