Commit d19d436

Iterators are a generalization of pointers that allow a C++ program to work with different data structures in a uniform way. Instead of operating on specific data types, algorithms operate on a range specified by a type of iterator. Any data structure that satisfies the requirements of the iterator can be operated upon by the algorithm. There are five types or categories of iterators:

Range adaptors create a *view* (one of the [View classes](view-classes.md) in the `std::views` namespace) from a range. We recommend that you use an adaptor in `std::ranges::views` instead of creating the view types directly. The adaptors are the intended way to access views. They're easier to use, and in some cases more efficient, than creating instances of the view types directly.

Creating a view only prepares to do work in the future. In the previous example, creating the view doesn't result in finding all the elements divisible by three. It also doesn't square the elements that it finds. That work happens only when you access an element in the view.

Elements of a view are usually the actual elements of the range that are used to create the view. The view usually doesn't own the elements ([`owning_view`](owning-view-class.md) is an exception); it just refers to them. Changing an element changes that element in the range that the view was created from. The following example shows this behavior:

description: "Learn more about range concepts and range iterator concepts."

title: "Concepts for ranges and range iterators"

ms.date: 11/02/2022

Concepts are a C++20 language feature that constrain template parameters at compile time. They help prevent incorrect template instantiation, convey template argument requirements in a readable form, and provide more succinct template related compiler errors.

The following concepts are defined in `std::ranges` and are declared in the `<ranges>` header file. They're used in the declarations of [range adaptors](range-adaptors.md), [views](view-classes.md), and so on.

| [`range`](#range)^C++20 | A type that provides an iterator and a sentinel. |

| [`bidirectional_range`](#bidirectional_range)^C++20 | Supports reading and writing forwards and backwards. |

| [`borrowed_range`](#borrowed_range)^C++20 | The lifetime of the type's iterators aren't tied to the object's lifetime. |

| [`common_range`](#common_range)^C++20 | The type of the iterator and the type of the sentinel are the same. |

| [`contiguous_range`](#contiguous_range)^C++20 | The elements are sequential in memory and can be accessed by using pointer arithmetic. |

| [`forward_range`](#forward_range)^C++20 | Supports reading (and possibly writing) a range multiple times. |

| [`input_range`](#input_range)^C++20 | Supports reading at least once. |

| [`output_range`](#output_range)^C++20 | Supports writing. |

| [`random_access_range`](#random_access_range)^C++20 | Supports reading and writing by index. |

| [`sized_range`](#sized_range)^C++20 | Provides the number of elements in a range efficiently. |

| [`view`](#view)^C++20 | Has efficient (constant time) move construction, assignment, and destruction. |

| [`viewable_range`](#viewable_range)^C++20 | A type that either is a view or can be converted to one. |

A `bidirectional_range` supports reading and writing forwards and backwards.

A `forward_range` supports reading (and possibly writing) a `range` multiple times.

An `input_range` is a `range` that can be read from at least once.

An `output_range` is a `range` that you can write to.

The essential requirement that makes a view composable is that it's cheap to move/copy. This is because the view is moved/copied when it's composed with another view. It must be a movable `range`.

constexpr std::add_pointer_t<ranges::range_reference_t</*const T*/>> cdata(T&& rg);