std::ranges::swap

 

C++

編譯器支援

自由（freestanding）與宿主（hosted）

語言

標準庫

標準庫標頭檔案

具名要求

特性測試宏 (C++20)

語言支援庫

概念庫 (C++20)

診斷庫

記憶體管理庫

超程式設計庫 (C++11)

通用工具庫

容器庫

迭代器庫

範圍庫 (C++20)

演算法庫

字串庫

文字處理庫

數值庫

日期和時間庫

輸入/輸出庫

檔案系統庫 (C++17)

併發支援庫 (C++11)

執行控制庫 (C++26)

技術規範

符號索引

外部庫

 

工具庫

語言支援 型別支援（基本型別、RTTI） 庫特性測試宏 (C++20) 程式工具 變參函式 initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) 協程支援 (C++20) 契約支援 (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)

 

定義於標頭檔案 <concepts>
namespace ranges {     inline namespace /* 未指定 */ {         inline constexpr /* 未指定 */ swap = /* 未指定 */;     } }		(C++20 起) (定製點物件)
呼叫簽名 (Call signature)
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. 否則，如果 t 和 u 是相等範圍（但可能不同元素型別）的左值陣列，且 ranges::swap(*t, *u) 是一個有效表示式，則為 (void)ranges::swap_ranges(t, u)，除了 noexcept((void)ranges::swap_ranges(t, u)) 等於 noexcept(ranges::swap(*t, *u))。
3. 否則，一個交換 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));
4. 否則，ranges::swap(t, u) 格式錯誤，當 ranges::swap(t, u) 出現在模板例項化的直接語境中時，可能導致替換失敗。

自定義點物件

名稱 ranges::swap 表示一個“自定義點物件 (customization point object)”，它是一個 const 函式物件，型別為字面型別的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	交換兩個物件的值 (函式模板)