std::ranges::views::adjacent, std::ranges::adjacent_view, std::ranges::views::pairwise

template< ranges::forward_range V, std::size_t N >
    requires ranges::view<V> && (N > 0)
class adjacent_view
    : public ranges::view_interface<adjacent_view<V, N>>

namespace views {
    template< std::size_t N >
    constexpr /* unspecified */ adjacent = /* unspecified */ ;
}

namespace views {
    inline constexpr auto pairwise = adjacent<2>;
}

template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto adjacent<N>( R&& r );

• S - N + 1, if S >= N,
• 0 otherwise, and the resulting view is empty.

• ((void)e, auto(views::empty<tuple<>>)) if N is equal to 0 and decltype((e)) models forward_range,
• adjacent_view<views::all_t<decltype((e))>, N>(e) otherwise.

adjacent_view always models forward_range, and models bidirectional_range, random_access_range, or sized_range if adapted view type models the corresponding concept.

Data members

Member functions

Deduction guides

(none)

Nested classes

Helper templates

template< class V, size_t N >
constexpr bool ranges::enable_borrowed_range<adjacent_view<V, N>> =
    ranges::enable_borrowed_range<V>;

This specialization of ranges::enable_borrowed_range makes adjacent_view satisfy borrowed_range when the underlying view satisfies it.

Notes

views::adjacent only accepts forward ranges even when N is 0.

There are similarities between ranges::adjacent_view and ranges::slide_view:

• Both create “sliding window” of size N.
• Both have the same size S - N + 1, where S is the size of an adapted view such that S >= N > 0.

The following table shows the differences between these adaptors:

Example

#include <print>
#include <ranges>
#include <tuple>

int main()
{
    static constexpr auto v = {1, 2, 3, 4, 5, 6};
    std::println("v = {}", v);

    for (int i{}; std::tuple t : v | std::views::adjacent<3>)
    {
        const auto [t0, t1, t2] = t;
        std::println("e = {:<{}}[{}, {}, {}]", "", 3 * i++, t0, t1, t2);
    }
}

v = [1, 2, 3, 4, 5, 6]
e = [1, 2, 3]
e =    [2, 3, 4]
e =       [3, 4, 5]
e =          [4, 5, 6]

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

References

• C++23 standard (ISO/IEC 14882:2024):
• 26.7.25 Adjacent view [range.adjacent]

See also