std::ranges::swap

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека утилит

Языковая поддержка Поддержка типов (базовые типы, RTTI) Макросы тестирования функциональности библиотеки (C++20)     Управление динамической памятью Программные утилиты Поддержка сопрограмм (C++20) Вариативные функции is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Трёхстороннее сравнение (C++20) 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_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(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) Элементарные преобразования строк to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

<tbody> </tbody>

Определено в заголовочном файле <concepts>
namespace ranges { inline namespace /* неопределено */ { inline constexpr /* неопределено */ swap = /* неопределено */; } }		(начиная с C++20) (объект точки настройки)
Сигнатура вызова
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. Иначе, (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 является 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) появляется в непосредственном контексте создания экземпляра шаблона.

Выражение эквивалентности

Выражение e это выражение эквивалентности для выражения f, если

• e и f имеют одинаковые эффекты, и
• либо оба являются константными подвыражениями, либо ни одно из них не является константным подвыражением, и
• либо оба являются потенциально генерирующими исключение либо ни одно из них не является потенциально генерирующим исключение (т.е. noexcept(e) == noexcept(f)).

Объекты точек настройки

Имя ranges::swap обозначает объект точки настройки, который является константным функциональным объектом литерального классового типа semiregular. В целях наглядности версия этого типа без cv-квалификации обозначается как __swap_fn.

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

    // char f1[]{1,2,3};
    // int  f2[]{4,5,6};
    // std::ranges::swap(f1, f2); // ошибка: swap(*f1, *f2) не найдена ADL

    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

Смотрите также

swappableswappable_with (C++20)	указывает, что тип можно обменять или что два типа можно обменять друг с другом (концепт)
swap	меняет местами значения двух объектов (шаблон функции)