# ConceptC++ Concept Web

## Concept RandomAccessIterator

```concept RandomAccessIterator<typename X> : BidirectionalIterator, LessThanComparable {
X& operator+=(X&, difference_type);
X  operator+ (X, difference_type);
X  operator+ (difference_type, X);
X& operator-=(X&, difference_type);
X  operator- (X, difference_type);
Â
difference_type operator-(X, X);
reference operator[](X, difference_type);
Â
bool operator>=(X, X);
bool operator>(X, X);
bool operator<=(X, X);
};```

### Where Defined

`#include <iterator>`

### Description

Random access iterators allow algorithms to move iterators an arbitrary number of steps forward or backward in constant time.

```X& operator+=(X&, difference_type);
```

Effects: equalivalent to

```{ difference_type m = n;
if (m >= 0) while (m--) ++r;
else while (m++) --r;
return r; }
```
```X operator+(X a, difference_type n);
X operator+(difference_type n, X a);
```

Effects: equivalent to

```{ X tmp = a;
return tmp += n; }
```

Postcondition: a + n == n + a

```X& operator-=(X& r, difference_type n);
```

Returns: r += -n

```X operator-(X, difference_type);
```

Effects: equivalent to

```{ X tmp = a;
return tmp -= n; } ```
```difference_type operator-(X a, X b);
```

Precondition: there exists a value n of difference_type such that a + n == b.

Effects: b == a + (b - a)

Returns: (a < b) ? distance(a,b) : -distance(b,a)

```bool operator>(X, X);
```

Effects: > is a total ordering relation opposite to <.

Pointers to constant values are random access iterators:

```template<typename T> concept_map RandomAccessIterator<const T*> {
typedef T value_type;
typedef std::ptrdiff_t difference_type;
typedef const T& reference;
typedef const T* pointer;
};```