std::ranges::swap

 

C++

コンパイラサポート

フリースタンディングとホスト

言語

標準ライブラリ

標準ライブラリヘッダー

名前付き要件

機能テストマクロ (C++20)

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

メモリ管理ライブラリ

メタプログラミングライブラリ (C++11)

汎用ユーティリティライブラリ

コンテナライブラリ

イテレータライブラリ

Rangesライブラリ (C++20)

アルゴリズムライブラリ

文字列ライブラリ

テキスト処理ライブラリ

数値ライブラリ

日付と時刻ライブラリ

入出力ライブラリ

ファイルシステムライブラリ (C++17)

並行サポートライブラリ (C++11)

実行制御ライブラリ (C++26)

Technical specifications (技術仕様)

シンボルインデックス

外部ライブラリ

 

ユーティリティライブラリ

言語サポート 型のサポート (基本型、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 /* 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 が両方とも std::move_constructible<V> および std::assignable_from<V&, 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 クラス型の const 関数オブジェクト である。説明のために、その型の 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)	型が交換可能であること、または2つの型が互いに交換可能であることを規定する (コンセプト)
swap	2つのオブジェクトの値を交換する (関数テンプレート)