std::random_access_iterator

template< class I >
    concept random_access_iterator =
        std::bidirectional_iterator<I> &&
        std::derived_from</*ITER_CONCEPT*/<I>, std::random_access_iterator_tag> &&
        std::totally_ordered<I> &&
        std::sized_sentinel_for<I, I> &&
        requires(I i, const I j, const std::iter_difference_t<I> n) {
            { i += n } -> std::same_as<I&>;
            { j +  n } -> std::same_as<I>;
            { n +  j } -> std::same_as<I>;
            { i -= n } -> std::same_as<I&>;
            { j -  n } -> std::same_as<I>;
            {  j[n]  } -> std::same_as<std::iter_reference_t<I>>;
        };

Концепция random_access_iterator уточняет bidirectional_iterator, добавив поддержку продвижения за постоянное время с операторами +=, +, -=, и -, вычисление расстояния за постоянное время с -, и запись массива с индексированием [].

Определение концепции итератора

Определение этой концепции задано через шаблон-псевдоним только для демонстрации /*ITER_CONCEPT*/.

Для определения /*ITER_CONCEPT*/<I>, пусть ITER_TRAITS<I> обозначает I в случае, если специализация std::iterator_traits<I> сгенерирована из основного шаблона, или std::iterator_traits<I> в противном случае:

• Если ITER_TRAITS<I>::iterator_concept валидно и задаёт тип, то /*ITER_CONCEPT*/<I> обозначает этот тип.
• В противном случае, если ITER_TRAITS<I>::iterator_category валидно и задаёт тип, то /*ITER_CONCEPT*/<I> обозначает этот тип.
• В противном случае, если std::iterator_traits<I> сгенерировано из основного шаблона, /*ITER_CONCEPT*/<I> обозначает std::random_access_iterator_tag.
• В противном случае, /*ITER_CONCEPT*/<I> не обозначает тип и приводит к ошибке подстановки.

Семантические требования

Пусть a и b — валидные итераторы типа I такие, что b достижимо из a, и пусть n — значение типа std::iter_difference_t<I> равное b - a. std::random_access_iterator<I> моделируется только если все подчинённые концепции моделированы и:

• (a += n) равно b.
• std::addressof(a += n) равно std::addressof(a). ^[1]
• (a + n) равно (a += n).
• (a + n) равно (n + a).
• Для любых двух положительных целых чисел x и y, если a + (x + y) валидно, то a + (x + y) равно (a + x) + y.
• a + 0 равно a.
• Если (a + (n - 1)) валидно, то --b равно (a + (n - 1)).
• (b += -n) и (b -= n) оба равны a.
• std::addressof(b -= n) равно std::addressof(b). ^[1]
• (b - n) равно (b -= n).
• Если b доступно для разыменования, то a[n] валидно и равно *b.
• bool(a <= b) является true.
• Каждая необходимая операция имеет постоянную сложность.

Обратите внимание, что std::addressof возвращает адрес объекта итератора, а не адрес объекта, на который указывает итератор. То есть, operator+= и operator-= должны возвращать ссылку на *this.

Сохранение равенства

Выражения, объявленные в выражениях requires стандартных библиотек концепций, должны быть сохраняющими равенство (за исключением случаев, когда это оговорено).

Неявные вариации выражений

Выражение requires, использующее выражение, которое не изменяет некоторое константное lvalue-операнд, также требует неявных вариаций выражений.

Примечания

В отличие от требований LegacyRandomAccessIterator, концепция random_access_iterator не требует, чтобы разыменование возвращало lvalue.

Пример

#include <iterator>
 
namespace cxx20
{
    template<std::input_or_output_iterator Iter>
    constexpr std::iter_difference_t<Iter> distance(Iter first, Iter last)
    {
        if constexpr(std::random_access_iterator<Iter>)
            return last - first;
        else
        {
            std::iter_difference_t<Iter> result{};
            for (; first != last; ++first)
                ++result;
            return result;
        }
    }
}
 
int main()
{
    static constexpr auto il = {3, 1, 4};
 
    static_assert(std::random_access_iterator<decltype(il.begin())> &&
                  cxx20::distance(il.begin(), il.end()) == 3 &&
                  cxx20::distance(il.end(), il.begin()) == -3);
}

См. также