Namespaces
Variants

    std::ranges::swap

    ja.cppreference.net より
     
    C++
    コンパイラサポート
    フリースタンディングとホスト環境
    言語
    標準ライブラリ
    標準ライブラリヘッダ
    名前付き要件
    機能テストマクロ (C++20)
    言語サポートライブラリ
    コンセプトライブラリ (C++20)
    診断ライブラリ
    メモリ管理ライブラリ
    メタプログラミングライブラリ (C++11)
    汎用ユーティリティライブラリ
    コンテナライブラリ
    イテレータライブラリ
    範囲ライブラリ (C++20)
    アルゴリズムライブラリ
    文字列ライブラリ
    テキスト処理ライブラリ
    数値ライブラリ
    日付と時刻ライブラリ
    入出力ライブラリ
    ファイルシステムライブラリ (C++17)
    並行処理サポートライブラリ (C++11)
    実行制御ライブラリ (C++26)
    技術仕様書
    シンボル索引
    外部ライブラリ
     
    ユーティリティライブラリ
    言語サポート
    型サポート (基本型、RTTI)
    ライブラリ機能テストマクロ (C++20)
    プログラムユーティリティ
    可変引数関数
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    コルーチンサポート (C++20)
    契約サポート (C++26)
    三方比較
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    汎用ユーティリティ
    関係演算子 (C++20で非推奨)
    整数比較関数
    (C++20)(C++20)(C++20)    
    (C++20)
    swap と 型操作
    (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 が参照する値を交換しない場合、プログラムは ill-formed です。診断は必要ありません。
    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) は ill-formed であり、置換失敗 を引き起こす可能性があります。これは ranges::swap(t, u) がテンプレートの実体化の直接の文脈に現れる場合に該当します。

    カスタマイゼーションポイントオブジェクト

    名前 ranges::swap は カスタマイゼーションポイントオブジェクト を表し、これは 関数オブジェクト のconstな リテラル semiregular クラス型である。詳細は CustomizationPointObject を参照。

    例

    このコードを実行 
    #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); // 異種型swapがサポートされている
    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)
    		型が交換可能であること、または2つの型が互いに交換可能であることを指定する
    (コンセプト)
    		2つのオブジェクトの値を交換する
    (関数テンプレート)