std::ranges::swap

namespace ranges {
    inline namespace /* unspecified */ {
        inline constexpr /* unspecified */ swap = /* unspecified */;
    }
}

template< class T, class U >
constexpr void ranges::swap( T&& t, U&& u ) noexcept(/* see below */);

Обменивает значения, на которые ссылаются 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 являются массивами lvalue с одинаковым размером (но, возможно, разными типами элементов), и ranges::swap(*t, *u) является допустимым выражением, за исключением того, что noexcept((void)ranges::swap_ranges(t, u)) равно noexcept(ranges::swap(*t, *u)).
3. В противном случае, выражение, которое обменивает значения, на которые ссылаются t и u, если они оба являются lvalue одного типа 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 является типом-литералом,
     • оба 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. Для целей пояснения, неквалифицированная версия его типа обозначается как __swap_fn.

Все экземпляры __swap_fn равны. Эффекты вызова различных экземпляров типа __swap_fn с одинаковыми аргументами эквивалентны, независимо от того, является ли выражение, обозначающее экземпляр, lvalue или rvalue, и квалифицировано ли оно как 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

См. также