# std::iter_swap(std::common_iterator)

< cpp‎ | iterator‎ | common iterator

template< std::indirectly_swappable<I> I2, class S2 > friend constexpr void iter_swap( const common_iterator& x, const std::common_iterator<I2, S2>& y ) noexcept(/*see below*/); |  | (C++20 起)

交换二个底层迭代器所指向的对象。若 `x` 不保有 `I` 对象或 `y` 不保有 `I2` 对象（即 `x` 与 `y` 中至少一个不保有迭代器）则行为未定义。

函数体等价于 ranges​::​iter_swap(std::get<I>(x.var), std::get<I2>(y.var)) 。

此函数模板对通常无限定或有限定查找不可见，而只能在 `std::common_iterator&ltI,S>` 为参数的关联类时由实参依赖查找找到。

### 参数

x, y | - | 指向要交换的元素的迭代器

### 返回值

（无）

### 复杂度

常数。

### 异常

`noexcept` 说明：
noexcept(noexcept(ranges::iter_swap(std::declval<const I&>(), std::declval<const I2&>())))

### 示例

    #include <algorithm>
    #include <iostream>
    #include <iterator>
    #include <string>
    #include <vector>

    int main()
    {
        std::vector<std::string> v1 { "1", "2", "3", "4", "5" },
                                 v2 { "α", "β", "γ", "δ", "ε" };

        using CI = std::common_iterator<
                       std::counted_iterator<std::vector<std::string>::iterator>,
                       std::default_sentinel_t
                       >;

        CI first1 { std::counted_iterator { v1.begin(), 3 } };
        CI first2 { std::counted_iterator { v2.begin(), 4 } };
        CI last   { std::default_sentinel };

        auto print = [&] (auto rem) {
            std::cout << rem << "v1 = ";
            std::ranges::copy(v1, std::ostream_iterator<std::string>{std::cout, " "});
            std::cout << "\nv2 = ";
            std::ranges::copy(v2, std::ostream_iterator<std::string>{std::cout, " "});
            std::cout << '\n';
        };

        print("Before iter_swap:\n");

        for (; first1 != last && first2 != last; ++first1, ++first2) {
            iter_swap( first1, first2 ); // ADL
        }

        print("After iter_swap:\n");
    }

输出：

    Before iter_swap:
    v1 = 1 2 3 4 5
    v2 = α β γ δ ε
    After iter_swap:
    v1 = α β γ 4 5
    v2 = 1 2 3 δ ε

### 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

DR | 应用于 | 出版时的行为 | 正确行为
--- | --- | --- | ---
LWG 3574 | C++20 | `variant` 为完全 constexpr (P2231R1) 但 `common_iterator` 不是 | 亦使之为 constexpr

### 参阅

swap | 交换两个对象的值 (函数模板)
swap_ranges | 交换两个范围的元素 (函数模板)
iter_swap | 交换两个迭代器所指向的元素 (函数模板)
iter_swap (C++20) | 交换两个可解引用对象所引用的值 (定制点对象)
iter_swap (C++20) | 交换二个底层迭代器所指向的对象 (函数模板)