std::ranges::swap

在标头 `<concepts>` 定义
inline namespace /* 未指定 / { inline constexpr / 未指定 / swap = / 未指定 */; }		(C++20 起) (定制点对象)

调用签名
template< class T, class U > requires /* 见下文 / constexpr void swap( T&& t, U&& u ) noexcept(/ 见下文 */);		(C++20 起)

交换 t 和 u 所引用的值。

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

(void)swap(t, u)，如果在命名空间 std::ranges 中，外加候选 template<class T> void swap(T&, T&) = delete; 进行重载决议时该表达式合法。
- 如果重载决议所选择的函数没有交换 t 和 u 所引用的值，那么程序非良构；不要求诊断。
否则是 (void)ranges::swap_ranges(t, u)，如果 t 和 u 是长度相等（但元素类型可能不同）的数组，且 ranges::swap(*t, *u) 是合法表达式，除了 noexcept(ranges::swap(t), ranges::swap(u)) 等于 noexcept(ranges::swap(*t, *u))；
否则是一个交换 t 和 u 所引用的值的表达式，如果它们都是具有相同类型 V 的左值，而 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>。
- 该表达式在满足以下所有条件时是常量表达式：
  - V 是字面类型 (LiteralType)
  - t = std::move(u)) 和 u = std::move(t) 都是常量子表达式
  - 以下声明中的初始化器的完整表达式都是常量子表达式：
    - V v1(std::move(t));
    - V v2(std::move(u));
否则，ranges::swap(t, u) 非良构，这能在 ranges::swap(t, u) 出现于模板实例化的立即语境时导致替换失败。

定制点对象

名字 ranges::swap 代表一个定制点对象，它是字面 semiregular 类类型的 const 函数对象。为说明目的，以 __swap_fn 表示它的类型的 cv 无限定版本。

__swap_fn 的所有实例均相等。在相同参数上调用类型 __swap_fn 的不同实例的效果是等价的，与指代该实例的表达式是左值还是右值，以及是否为 const 限定无关（然而不要求 volatile 限定的实例可调用）。从而能自由地复制 ranges::swap 并且能彼此替代地使用它的副本。

给定类型集合 Args...，如果 std::declval<Args>()... 满足上面对于 ranges::swap 的参数要求，那么 __swap_fn 实现

std::invocable<__swap_fn, Args...>、
std::invocable<const __swap_fn, Args...>、
std::invocable<__swap_fn&, Args...> 和
std::invocable<const __swap_fn&, Args...>。

否则，__swap_fn 的函数调用运算符不会参与重载决议。

示例

运行此代码

#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

参阅

swappableswappable_with (C++20)	指定一个类型能进行交换，或两个类型能彼此交换 (概念)
swap	交换两个对象的值 (函数模板)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

std::ranges::swap

定制点对象

示例

参阅

导航