std::ranges::view_interface

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Ranges library

Range access
begin cbegin end cend	rbegin crbegin rend crend	size ssize data cdata	empty
Range primitives
iterator_tsentinel_t	range_size_trange_difference_t	range_value_t	range_reference_trange_rvalue_reference_t
Dangling iterator handling
dangling	borrowed_iterator_t	borrowed_subrange_t
Range concepts
range borrowed_range sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range random_access_range contiguous_range
Views
view_interface	subrange
Semiregular wrapper
Factories
empty_viewviews::empty	single_viewviews::single	iota_viewviews::iota	views::counted
Adaptors
views::all_tviews::all join_viewviews::join take_viewviews::take basic_istream_viewistream_view	ref_view                                split_viewviews::split take_while_viewviews::take_while elements_viewviews::elements	common_viewviews::common transform_viewviews::transform drop_viewviews::drop keys_viewviews::keys	reverse_viewviews::reverse filter_viewviews::filter drop_while_viewviews::drop_while values_viewviews::values

 

Defined in header <ranges>
template<class D>   requires std::is_class_v<D> && std::same_as<D, std::remove_cv_t<D>> class view_interface : public view_base;		(since C++20)

std::ranges::view_interface is a helper class template for defining a view interface.

view_interface is typically used with CRTP:

class my_view : public std::ranges::view_inteface<my_view> {
public:
    auto begin() const { /*...*/ }
    auto end() const { /*...*/ }
    // empty() is provided if begin() returns a forward iterator
    // and end() returns a sentinel for it.
};

Member functions

empty	Returns whether the deriving view is empty. (public member function)
operator bool	Returns whether the deriving view is not empty. (public member function)
data	Get the address of deriving view's data. Provided if it satisfies contiguous_iterator (public member function)
size	returns the number of elements. Provided only if the underlying (adapted) range satisfies sized_range (public member function)
front	Return the first element in the deriving view. (public member function)
back	Return the last element in the deriving view. Provided if it satisfies bidirectional_range and common_range (public member function)
operator[]	Return the nth element in the deriving view. Provided if it satisfies random_access_range (public member function)

Example

Run this code

#include <ranges>
#include <vector>
#include <iostream>
 
template <class T, class A>
class VectorView : public std::ranges::view_interface<VectorView<T, A>> {
public:
    // We need to define a default constructor to satisfy the view concept.
    VectorView() = default;
    VectorView(const std::vector<T, A>& vec) :
        m_begin(vec.cbegin()), m_end(vec.cend()) {}
    auto begin() const { return m_begin; }
    auto end() const { return m_end; }
private:
    typename std::vector<T, A>::const_iterator m_begin, m_end;
};
 
int main()
{
    std::vector<int> v = {1, 4, 9, 16};
 
    VectorView view_over_v{v};
 
    // We can iterate with begin() and end().
    for (int n : view_over_v) {
        std::cout << n << ' ';
    }
    std::cout << '\n';
 
    // We get operator[] for free when inherting from view_interface
    // since we satisfy the random_access_range concept.
    for (std::ptrdiff_t i = 0; i < view_over_v.size(); i++) {
        std::cout << "v[" << i << "] = " << view_over_v[i] << '\n';
    }
}

Output:

1 4 9 16 
v[0] = 1
v[1] = 4
v[2] = 9
v[3] = 16

See also

subrange

combines an iterator-sentinel pair into a view (class template)