std::ranges::swap

 

C++

编译器支持

独立和宿主

语言

标准库

标准库头文件

命名需求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用实用程序库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

实用程序库

语言支持 类型支持 (基本类型，RTTI) 库特性测试宏 (C++20) 动态内存管理 程序实用程序 协程支持 (C++20) 可变参数函数 is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) 调试支持 is_debugger_present (C++26) breakpoint_if_debugging (C++26) breakpoint (C++26) 三路比较 three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)    is_eqis_ltis_lteq (C++20)(C++20)(C++20) is_neqis_gtis_gteq (C++20)(C++20)(C++20)

通用实用程序 日期和时间 函数对象 格式化库 (C++20) bitset hash (C++11) 关系运算符 (C++20 中已弃用) rel_ops::operator!=rel_ops::operator>     rel_ops::operator<=rel_ops::operator>= 整数比较函数 cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)    cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) 交换 和 类型操作 swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) 通用词汇类型 pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) 基本字符串转换 to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

定义在头文件 <concepts> 中
namespace ranges {     inline namespace /* 未指定 */ {         inline constexpr /* 未指定 */ swap = /* 未指定 */;     } }		(自 C++20 起) (自定义点对象)
调用签名
template< class T, class U > constexpr void ranges::swap( T&& t, U&& u ) noexcept(/* 见下文 */);		(自 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>.
   • 如果该表达式是一个 常量表达式，则
     • V 是一个 LiteralType，
     • t = std::move(u)) 和 u = std::move(t) 都是 常量子表达式，并且
     • 以下声明中初始值设定项的 完整表达式 是常量子表达式
       • V v1(std::move(t));
       • V v2(std::move(u));
4. 否则，ranges::swap(t, u) 格式错误，这会导致 替换失败，当 ranges::swap(t, u) 出现在模板实例化的直接上下文中时。

自定义点对象

名称 ranges::swap 表示一个自定义点对象，它是一个常量 函数对象，属于 字面量 semiregular 类类型。为了便于说明，其类型的 cv 无限定版本表示为 __swap_fn。

所有 __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); // error: no swap found by ADL
 
    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); // error: extents mismatch
 
    // char f1[]{1, 2, 3};
    // int  f2[]{4, 5, 6};
    // std::ranges::swap(f1, f2); // error: no swap(*f1, *f2) found by ADL
 
    IntLike g1[]{1, 2, 3};
    int     g2[]{4, 5, 6};
    std::ranges::swap(g1, g2); // heterogeneous swap supported
    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	交换两个对象的的值 (函数模板)