std::ranges::swap

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI, type traits)      Library feature-test macros (C++20) Dynamic memory management Program utilities Error handling Coroutine support (C++20) Variadic functions is_constant_evaluated (C++20) launder (C++17) initializer_list (C++11) source_location (C++20) Three-way comparison (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)

General utilities Date and time Function objects Formatting library (C++20) bitset hash (C++11) integer_sequence (C++14) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Integer comparison functions 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 and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) forward (C++11) move (C++11) move_if_noexcept (C++11) as_const (C++17) to_underlying (C++23) Common vocabulary types 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) Elementary string conversions to_chars (C++17) from_chars (C++17) chars_format (C++17)

 

Defined in header <concepts>
inline namespace /* unspecified */ {     inline constexpr /* unspecified */ swap = /* unspecified */; }		(since C++20) (customization point object)
Call signature
template< class T, class U >     requires /* see below */ constexpr void swap(T&& t, U&& u) noexcept(/* see below */);

Exchanges the values referenced by t and u.

A call to ranges::swap:

1. is expression-equivalent to (void)swap(std::forward<T>(t), std::forward<U>(u)), if that expression is valid, where the overload resolution is performed with the following candidates:
   • template<class T> void swap(T&, T&) = delete;
   • template<class T, std::size_t N> void swap(T(&)[N], T(&)[N]) = delete;
   • any declarations of swap found by argument-dependent lookup.

   If the function selected by overload resolution does not exchange the values referenced by t and u, the program is ill-formed; no diagnostic required.

2. Otherwise, is expression-equivalent to (void)ranges::swap_ranges(t, u) except that noexcept(ranges::swap(t, u)) is equal to noexcept(ranges::swap(*t, *u)), if T and U are lvalue references to array types of equal extent (but possibly different element types) and ranges::swap(*t, *u) is a valid expression;
3. Otherwise, exchanges the referenced values as if by V v(std::move(t)); t = std::move(u); u = std::move(v);, if T and U are both lvalue references to V for some type V that satisfies std::move_constructible<V> and std::assignable_from<V&, V>.
   • Whether the call is potentially throwing is specified by above operations.
   • The call is a constant subexpression if both above operations and the operations performed with u and v swapped are usable in constant evaluation.

   If either concept is not modeled, the program is ill-formed; no diagnostic required.

4. In all other cases, a call to ranges::swap is ill-formed, which can result in substitution failure when ranges::swap(t, u) appears in the immediate context of a template instantiation.

Expression-equivalent

Expression e is expression-equivalent to expression f, if e and f have the same effects, either are both potentially-throwing or are both not potentially-throwing (i.e. noexcept(e) == noexcept(f)), and either are both constant subexpressions or are both not constant subexpressions.

Customization point objects

The name ranges::swap denotes a customization point object, which is a const function object of a literal semiregular class type. For exposition purposes, the cv-unqualified version of its type is denoted as __swap_fn.

All instances of __swap_fn are equal. The effects of invoking different instances of type __swap_fn on the same arguments are equivalent, regardless of whether the expression denoting the instance is an lvalue or rvalue, and is const-qualified or not (however, a volatile-qualified instance is not required to be invocable). Thus, ranges::swap can be copied freely and its copies can be used interchangeably.

Given a set of types Args..., if std::declval<Args>()... meet the requirements for arguments to ranges::swap above, __swap_fn models std::invocable<__swap_fn, Args...>, std::invocable<const __swap_fn, Args...>, std::invocable<__swap_fn&, Args...>, and std::invocable<const __swap_fn&, Args...>. Otherwise, no function call operator of __swap_fn participates in overload resolution.

Example

Run this code

#include <array>
#include <concepts>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
 
void print(std::string_view const 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 const name, int p, int q)
{
    std::cout << name << "1 = " << p << ", " << name << "2 = " << q << '\n';
}
 
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: types mismatch
 
    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: types mismatch
 
    // char f1[]{1,2,3};
    // int  f2[]{4,5,6};
    // std::ranges::swap(f1, f2); // error: types mismatch
 
    int g1{27}, g2{28};
    std::ranges::swap(g1, g2);
    print("g", g1, g2);
}

Output:

a1{ 13 14 }, a2{ 10 11 12 }
b1{ 18 19 20 }, b2{ 15 16 17 }
d1{ 24 25 26 }, d2{ 21 22 23 }
g1 = 28, g2 = 27

See also

swappableswappable_with (C++20)	specifies that a type can be swapped or that two types can be swapped with each other (concept)
swap	swaps the values of two objects (function template)