std::iter_swap

From cppreference.com
< cpp‎ | algorithm
 
 
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
(C++11)(C++11)(C++11)
(C++17)
Modifying sequence operations
Partitioning operations
Sorting operations
(C++11)
Binary search operations
Set operations (on sorted ranges)
Heap operations
(C++11)
Minimum/maximum operations
(C++11)
(C++17)

Permutations
Numeric operations
Operations on uninitialized storage
(C++17)
(C++17)
(C++17)
C library
 
Defined in header <algorithm>
template< class ForwardIt1, class ForwardIt2 >
void iter_swap( ForwardIt1 a, ForwardIt2 b );
(until C++20)
template< class ForwardIt1, class ForwardIt2 >
constexpr void iter_swap( ForwardIt1 a, ForwardIt2 b );
(since C++20)

Swaps the values of the elements the given iterators are pointing to.

Parameters

a, b - iterators to the elements to swap
Type requirements
-
ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator.
-
*a, *b must meet the requirements of Swappable.

Return value

(none)

Complexity

constant

Notes

This function template models the semantics of the swap operation given by Swappable. That is, overloads of swap found by ADL and the fall back of std::swap are considered.

Possible implementation

template<class ForwardIt1, class ForwardIt2>
constexpr void iter_swap(ForwardIt1 a, ForwardIt2 b) // constexpr since C++20
{
    using std::swap;
    swap(*a, *b);
}

Example

The following is an implementation of selection sort in C++.

#include <algorithm>
#include <functional>
#include <iostream>
#include <random>
#include <vector>
 
template<class ForwardIt>
void selection_sort(ForwardIt begin, ForwardIt end)
{
    for (ForwardIt i = begin; i != end; ++i)
        std::iter_swap(i, std::min_element(i, end));
}
 
int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dist(-9, +9);
    std::vector<int> v;
    std::generate_n(back_inserter(v), 20, bind(dist, gen));
 
    std::cout << "Before sort: " << std::showpos;
    for (auto e : v)
        std::cout << e << ' ';
 
    selection_sort(v.begin(), v.end());
 
    std::cout << "\nAfter sort : ";
    for (auto e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}

Possible output:

Before sort: -9 -3 +2 -8 +0 -1 +8 -4 -5 +1 -4 -5 +4 -9 -8 -6 -6 +8 -4 -6 
After sort : -9 -9 -8 -8 -6 -6 -6 -5 -5 -4 -4 -4 -3 -1 +0 +1 +2 +4 +8 +8

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 187 C++98 it was unspecified whether swap is used the effect is equivalent to swap(*a, *b)

See also

swaps the values of two objects
(function template)
swaps two ranges of elements
(function template)
(C++20)
swaps the objects pointed to by two adjusted underlying iterators
(function template)
(C++20)
swaps the objects pointed to by two underlying iterators
(function template)
(C++20)
swaps the values referenced by two dereferenceable objects
(customization point object)