std::ranges:: swap

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. そうでなければ、両方が同じ型 V の左辺値であり、かつ std:: move_constructible < V > および std:: assignable_from < V & , V > をモデルとする場合、 t と u の参照先の値を交換する式。
   • その式に 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 は カスタマイゼーションポイントオブジェクト を表し、これは 関数オブジェクト の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

関連項目