Namespaces
Variants

    std::ranges::swap

    来自 zh.cppreference.net
     
    C++
     
    工具库
    通用工具
    关系运算符 (C++20 弃用)
    整数比较函数
    (C++20)(C++20)(C++20)    
    (C++20)
    交换 与 类型操作
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    常用词汇类型
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    在头文件 <concepts> 
    namespace ranges {
    inline namespace /* unspecified */ {
        inline constexpr /* unspecified */ swap = /* unspecified */;
    }
}
    		中定义(C++20 起)
    (定制点对象)
    调用签名
    		 
    template< class T, class U >
constexpr void ranges::swap( T&& t, U&& u ) noexcept(/* see below */);
    		(C++20 起)

    交换由 t 和 u 所引用的值。

    ranges::swap(t, u) 是 表达式等价于：

    1. (void)swap(t, u)，如果 t 或 u 拥有类或枚举类型，且该表达式合法，其中 重载决议在命名空间 std::ranges 内连同附加的候选 template<class T> void swap(T&, T&) = delete; 一起进行。
      • 如果重载决议所选择的函数并未交换 t 和 u 所引用的值，那么程序为非良构（无需诊断）。
    2. 否则，(void)ranges::swap_ranges(t, u)，如果 t 和 u 是相同大小的左值数组（但元素类型可能不同），且 ranges::swap(*t, *u) 是合法表达式，但 noexcept((void)ranges::swap_ranges(t, u)) 等于 noexcept(ranges::swap(*t, *u))。
    3. 否则，当 t 和 u 都是同一类型 V 的左值，且该类型满足 std::move_constructible<V> 及 std::assignable_from<V&, V> 概念时，则产生一个交换它们所引用值的表达式。
      • 对该表达式应用 noexcept运算符 的结果等于 std::is_nothrow_move_constructible_v<V> && std::is_nothrow_move_assignable_v<V>。
      • 该表达式是一个常量表达式，如果
    4. 否则，ranges::swap(t, u) 为非良构，这会在 出现在模板实例化的立即上下文时导致替换失败ranges::swap(t, u)。

    定制点对象

    名称 ranges::swap 表示一个 定制点对象 ，这是一个常量 函数对象 ，其类型为 字面量 的 semiregular 类类型。详情请参阅 定制点对象 。

    示例

    运行此代码 
    #include <array>
#include <concepts>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
void print(std::string_view name, 
           std::ranges::common_range auto const& p, 
           std::ranges::common_range auto const& q)
{
    std::cout << name << "1{ ";
    for (auto const& i : p)
        std::cout << i << ' ';
    std::cout << "}, " << name << "2{ ";
    for (auto const& i : q)
        std::cout << i << ' ';
    std::cout << "}\n";
}
void print(std::string_view name, int p, int q)
{
    std::cout << name << "1 = " << p << ", " << name << "2 = " << q << '\n';
}
struct IntLike
{
    int v;
};
void swap(IntLike& lhs, int& rhs)
{
    std::swap(lhs.v, rhs);
}
void swap(int& lhs, IntLike& rhs)
{
    std::swap(lhs, rhs.v);
}
std::ostream& operator<<(std::ostream& out, IntLike i)
{
    return out << i.v;
}
int main()
{
    std::vector a1{10, 11, 12}, a2{13, 14};
    std::ranges::swap(a1, a2);
    print("a", a1, a2);
    std::array b1{15, 16, 17}, b2{18, 19, 20};
    std::ranges::swap(b1, b2);
    print("b", b1, b2);
    // std::array c1{1, 2, 3}; std::array c2{4, 5};
    // std::ranges::swap(c1, c2); // 错误：ADL未找到swap函数
    int d1[]{21, 22, 23}, d2[]{24, 25, 26};
    std::ranges::swap(d1, d2);
    print("d", d1, d2);
    // int e1[]{1, 2, 3}, e2[]{4, 5};
    // std::ranges::swap(e1, e2); // 错误：数组长度不匹配
    // char f1[]{1, 2, 3};
    // int  f2[]{4, 5, 6};
    // std::ranges::swap(f1, f2); // 错误：ADL未找到swap(*f1, *f2)
    IntLike g1[]{1, 2, 3};
    int     g2[]{4, 5, 6};
    std::ranges::swap(g1, g2); // 支持异构交换
    print("g", g1, g2);
    int h1{27}, h2{28};
    std::ranges::swap(h1, h2);
    print("h", h1, h2);
}

    输出： 

    a1{ 13 14 }, a2{ 10 11 12 }
b1{ 18 19 20 }, b2{ 15 16 17 }
d1{ 24 25 26 }, d2{ 21 22 23 }
g1{ 4 5 6 }, g2{ 1 2 3 }
h1 = 28, h2 = 27

    参见

    (C++20)
    		指定类型可交换或两种类型可相互交换
    (概念)
    		交换两个对象的值
    (函数模板)