Namespaces
Variants

std:: swap_ranges

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
swap_ranges

Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Определено в заголовке <algorithm>
template < class ForwardIt1, class ForwardIt2 >

ForwardIt2 swap_ranges ( ForwardIt1 first1, ForwardIt1 last1,

ForwardIt2 first2 ) ;
(1) (constexpr начиная с C++20)
template < class ExecutionPolicy,

class ForwardIt1, class ForwardIt2 >
ForwardIt2 swap_ranges ( ExecutionPolicy && policy,
ForwardIt1 first1, ForwardIt1 last1,

ForwardIt2 first2 ) ;
(2) (начиная с C++17)
1) Обменивает элементы между диапазоном [ first1 , last1 ) и другим диапазоном из std:: distance ( first1, last1 ) элементов, начинающимся с first2 .
2) То же, что и (1) , но выполняется в соответствии с policy .
Эта перегрузка участвует в разрешении перегрузки только при выполнении всех следующих условий:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> равно true .

(до C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> равно true .

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

Если выполняется любое из следующих условий, поведение не определено:

  • Два диапазона перекрываются.
  • Существует пара соответствующих итераторов iter1 и iter2 в двух диапазонах, таких что * iter1 не является Swappable с * iter2 .

Содержание

Параметры

first1, last1 - пара итераторов, определяющих диапазон элементов для обмена
first2 - начало второго диапазона элементов для обмена
policy - политика выполнения для использования
Требования к типам
-
ForwardIt1, ForwardIt2 должны соответствовать требованиям LegacyForwardIterator .

Возвращаемое значение

Итератор на элемент, следующий за последним элементом, обмененным в диапазоне, начинающемся с first2 .

Сложность

Ровно std:: distance ( first1, last1 ) обменов.

Исключения

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

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

Примечания

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

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

template<class ForwardIt1, class ForwardIt2>
constexpr //< since C++20
ForwardIt2 swap_ranges(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2)
{
    for (; first1 != last1; ++first1, ++first2)
        std::iter_swap(first1, first2);
    return first2;
}
**Примечание:** Весь код C++ внутри тегов `
` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Пример

Демонстрирует обмен поддиапазонами из разных контейнеров.

#include <algorithm>
#include <iostream>
#include <list>
#include <vector>
auto print = [](auto comment, auto const& seq)
{
    std::cout << comment;
    for (const auto& e : seq)
        std::cout << e << ' ';
    std::cout << '\n';
};
int main()
{
    std::vector<char> v{'a', 'b', 'c', 'd', 'e'};
    std::list<char> l{'1', '2', '3', '4', '5'};
    print("Before swap_ranges:\n" "v: ", v);
    print("l: ", l);
    std::swap_ranges(v.begin(), v.begin() + 3, l.begin());
    print("After swap_ranges:\n" "v: ", v);
    print("l: ", l);
}

Вывод:

Before swap_ranges:
v: a b c d e
l: 1 2 3 4 5
After swap_ranges:
v: 1 2 3 d e
l: a b c 4 5

Смотрите также

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