Namespaces
Variants

std::reverse

Из ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы над диапазонами (C++20)
Ограниченные алгоритмы, например, ranges::copy, ranges::sort, ...
Неизменяющие операции над последовательностями    
Пакетные операции
(C++17)
Операции поиска
Изменяющие операции над последовательностями
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(до C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разбиения
(C++11)    

Операции сортировки
Операции бинарного поиска
(на разбитых диапазонах)
Операции над множествами (на отсортированных диапазонах)
Операции слияния (на отсортированных диапазонах)
Операции с кучей
Операции поиска минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановок


Политики выполнения (C++17)
(только для пояснения*)(C++26)

Числовые операции
(C++11)
(C++17)
(C++17)    

Специализированные <memory> алгоритмы

Специализированные <random> алгоритмы
Библиотека C









 
Определено в заголовке <algorithm>
template< class BidirIt >
void reverse( BidirIt first, BidirIt last );
(1) (constexpr, начиная с C++20)
template< class ExecutionPolicy, class BidirIt >
void reverse( ExecutionPolicy&& policy, BidirIt first, BidirIt last );
(2) (начиная с C++17)
1) Изменяет порядок элементов в диапазоне [first, last).
Ведёт себя так, как если бы применялась std::iter_swap для каждой пары итераторов first + i и (last - i) - 1 для каждого целого числа i в [0, std::distance(first, last) / 2).
2) То же, что и (1), но выполняется в соответствии с policy.
Эта перегрузка участвует в разрешении перегрузки только если значение следующего выражения равно true:

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

(до C++20)

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

(начиная с C++20)

Если *first не является Swappable(до C++20)BidirIt не является ValueSwappable(начиная с C++20), поведение не определено.

Параметры

first, last - пара итераторов, определяющих диапазон элементов для обращения
policy - политика выполнения для использования
Требования к типам
-
BidirIt должен удовлетворять требованиям LegacyBidirectionalIterator .

Сложность

Ровно std:: distance ( first, last ) / 2 обменов.

Исключения

Перегрузка с параметром шаблона с именем ExecutionPolicy сообщает об ошибках следующим образом:

  • Если выполнение функции, вызванной как часть алгоритма, выбрасывает исключение и ExecutionPolicy является одним из стандартных политик , std::terminate вызывается. Для любой другой ExecutionPolicy поведение определяется реализацией.
  • Если алгоритму не удается выделить память, std::bad_alloc выбрасывается.

Возможная реализация

Смотрите также реализации в libstdc++ , libc++ , и MSVC STL .

template<class BidirIt>
constexpr // начиная с C++20
void reverse(BidirIt first, BidirIt last)
{
    using iter_cat = typename std::iterator_traits<BidirIt>::iterator_category;
    // Диспетчеризация по тегам, например, вызов reverse_impl(first, last, iter_cat()),
    // может использоваться в режимах C++14 и более ранних.
    if constexpr (std::is_base_of_v<std::random_access_iterator_tag, iter_cat>)
    {
        if (first == last)
            return;
        for (--last; first < last; (void)++first, --last)
            std::iter_swap(first, last);
    }
    else
        while (first != last && first != --last)
            std::iter_swap(first++, last);
}

Примечания

Реализации (например, MSVC STL ) могут использовать векторизацию, когда тип итератора удовлетворяет требованиям LegacyContiguousIterator и обмен его типа значений не вызывает ни нетривиальные специальные функции-члены, ни ADL -найденную функцию swap .

Пример

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
void println(auto rem, auto const& v)
{
    for (std::cout << rem; auto e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
int main()
{
    std::vector<int> v {1, 2, 3};
    std::reverse(v.begin(), v.end());
    println("after reverse, v = ", v);
    int a[] = {4, 5, 6, 7};
    std::reverse(std::begin(a), std::end(a));
    println("after reverse, a = ", a);
}

Вывод:

after reverse, v = 3 2 1
after reverse, a = 7 6 5 4

Отчёты о дефектах

Следующие отчеты об изменениях в поведении, содержащие описания дефектов, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Applied to Behavior as published Correct behavior
LWG 223 C++98 std::swap применялся к каждой паре итераторов применяется std::iter_swap вместо этого
LWG 2039 C++98 std::iter_swap также применялся, когда i
равно std:: distance ( first, last ) / 2
не применяется

См. также

создаёт копию диапазона с обратным порядком элементов
(шаблон функции & объект алгоритма)
изменяет порядок элементов в диапазоне на обратный
(объект алгоритма)