N4284: Contiguous Iterators

Introduction

Wording Changes

Iterators that further satisfy the requirements of output iterators are called mutable iterators. Nonmutable iterators are referred to as constant iterators.

Iterators that further satisfy the requirement that, for integral values n and dereferenceable iterator values a and (a + n), *(a + n) is equivalent to *(addressof(*a) + n), are called contiguous iterators. [ Note: For example, the type "pointer to int" is a contiguous iterator, but reverse_iterator<int *> is not. For a valid iterator range [a, b) with dereferenceable a, the corresponding range denoted by pointers is [addressof(*a), addressof(*a) + (b - a) ); b might not be dereferenceable. -- end note ]

The iterators supported by basic_string are random access iterators (24.2.7 [random.access.iterators]). A basic_string is a contiguous container (23.2.1 [container.requirements.general]).

The char-like objects in a basic_string object shall be stored contiguously. That is, for any basic_string object s, the identity &*(s.begin() + n) == &*s.begin() + n shall hold for all values of n such that 0 <= n < s.size().

Unless otherwise specified (either explicitly or by defining a function in terms of other functions), invoking a container member function or passing a container as an argument to a library function shall not invalidate iterators to, or change the values of, objects within that container.

A contiguous container is a container that supports random access iterators (24.2.7 [random.access.iterators]) and whose member types iterator and const_iterator are contiguous iterators (24.2.1 [iterator.requirements.general]).

... An array supports random access iterators is a contiguous container. ... The elements of an array are stored contiguously, meaning that if a is an array<T, N> then it obeys the identity &a[n] == &a[0] + n for all 0 <= n < N.

A vector is a sequence container that supports random access iterators . In addition, it supports (amortized) constant time insert and erase operations at the end; insert and erase in the middle take linear time. ... The elements of a vector are stored contiguously, meaning that if v is a vector where T is some type otherthan bool, then it obeys the identity &v[n] == &v[0] + n for all 0 <= n < v.size().

A vector satisfies all of the requirements of a container and of a reversible container (given in two tables in 23.2), of a sequence container, including most of the optional sequence container requirements (23.2.3 [sequence.reqmts]), and of an allocator-aware container (Table 99), and, for an element type other than bool, of a contiguous container (23.2.1 [container.requirements.general]). The exceptions are ...

In the begin and end function templates that follow, unspecified1 is a type that meets the requirements of a mutable random access iterator (24.2.7 [random.access.iterators]) and of a contiguous iterator (24.2.1 iterator.requirements.general]) whose value_type is the template parameter T and whose reference type is T&. unspecified2 is a type that meets the requirements of a constant random access iterator (24.2.7 [random.access.iterators]) and of a contiguous iterator (24.2.1 [iterator.requirements.general]) whose value_type is the template parameter T and whose reference type is const T&.

typedef implementation-defined const_iterator;

A constant random-access and contiguous iterator type such that, for a const_iterator it, if &*(it+N) is valid, then it is equal to (&*it)+N.