Concept RandomAccessIteratorconcept 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> DescriptionRandom 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;
};
|