Defined in header <ranges>  

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>>  (1)  (since C++23) 
namespace views { template< size_t N > inline constexpr /* unspecified */ adjacent = /* unspecified */ ; }  (2)  (since C++23) 
namespace views { inline constexpr auto pairwise = adjacent<2>; }  (3)  (since C++23) 
Call signature  
template< ranges::viewable_range R > requires /* see below */ constexpr ranges::view auto adjacent<N>( R&& r );  (since C++23) 
adjacent_view
is a range adaptor that takes a view
, and produces a view
whose i
th element (a "window") is a tuplelike value that holds N
references to the elements of the original view, from i
^{th} up to i + N  1
^{th} inclusively.S
be the size of the original view. Then the size of produced view is: S  N + 1
, if S >= N
, 0
otherwise, and the resulting view is empty.views::adjacent<N>
denotes a ranges adaptor object. Given a subexpression e
and a constant expression N
, the expression views::adjacent<N>(e)
is expressionequivalent to ((void)e, auto(views::empty<tuple<>>))
if N
is equal to 0
, 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.
Expression e
is expressionequivalent to expression f
, if.
e
and f
have the same effects, and noexcept(e) == noexcept(f)
). Typical implementations of adjacent_view
hold only one nonstatic data member base_
of type V
. The name is for exposition only.
(C++23)  constructs a adjacent_view (public member function) 
(C++23)  returns an iterator to the beginning (public member function) 
(C++23)  returns an iterator or a sentinel to the end (public member function) 
(C++23)  returns the number of elements. Provided only if the underlying (adapted) range satisfies sized_range . (public member function) 
Inherited from 

(C++20)  Returns whether the derived view is empty. Provided if it satisfies sized_range or forward_range . (public member function of std::ranges::view_interface<D> ) 
(C++20)  Returns whether the derived view is not empty. Provided if ranges::empty is applicable to it. (public member function of std::ranges::view_interface<D> ) 
(C++20)  Returns the first element in the derived view. Provided if it satisfies forward_range . (public member function of std::ranges::view_interface<D> ) 
(C++20)  Returns the last element in the derived view. Provided if it satisfies bidirectional_range and common_range . (public member function of std::ranges::view_interface<D> ) 
(C++20)  Returns the nth element in the derived view. Provided if it satisfies random_access_range . (public member function of std::ranges::view_interface<D> ) 
(none).
(C++23)  the iterator type (expositiononly member class template) 
(C++23)  the sentinel type used when adjacent_view is not a common_range (expositiononly member class template) 
template< class V, size_t N > inline constexpr bool enable_borrowed_range<adjacent_view<V, N>> = enable_borrowed_range<V>;  (since C++23) 
This specialization of ranges::enable_borrowed_range
makes adjacent_view
satisfy borrowed_range
when the underlying view satisfies it.
There is a similarity between ranges::adjacent_view
and ranges::slide_view
— they both produce a "sliding window" of the size N
, and, given a view
of the size S
, they both will have the same size: S  N + 1
. The difference between these view
adaptors are:
View adaptor  value_type  The window size N is 

ranges::adjacent_view  tuplelike object  a template parameter 
ranges::slide_view  a range
 a runtime parameter 
Featuretest macro  Value  Std 

__cpp_lib_ranges_zip  202110L  (C++23) 
#include <array> #include <tuple> #include <ranges> #include <string> #include <cstddef> #include <iostream> int main() { constexpr std::size_t window{3}; constexpr std::array v {1, 2, 3, 4, 5, 6}; std::cout << "v = [1 2 3 4 5 6]\n"; for (int i{}; auto const e: v  std::views::adjacent<window>(v)) { std::cout << "e = " << std::string(2 * i++, ' ') << '[' << std::get<0>(e) << ' ' << std::get<1>(e) << ' ' << std::get<2>(e) << "]\n"; } }
Output:
v = [1 2 3 4 5 6] e = [1 2 3] e = [2 3 4] e = [3 4 5] e = [4 5 6]
(C++23)  a view consisting of tuples of results of application of a transformation function to adjacent elements of the adapted view (class template) (range adaptor object) 
(C++23)  a view whose M^{th} element is a view over the M^{th} through (M + N  1)^{th} elements of another view (class template) (range adaptor object) 
(C++23)  a range of view s that are N sized nonoverlapping successive chunks of the elements of another view (class template) (range adaptor object) 
(C++23)  a view consisting of elements of another view , advancing over N elements at a time (class template) (range adaptor object) 
© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/ranges/adjacent_view