std::ranges::swap
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Utilities library
Type support (basic types, RTTI)
Library feature-test macros (C++20)
(C++11)
(C++20)
(C++26)
(C++20)
Coroutine support (C++20)
Contract support (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)
General utilities
Relational operators (deprecated in C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
(C++20)
Swap and type operations
Common vocabulary types
Defined in header
<concepts>
namespace ranges {
(since C++20) inline namespace /* unspecified */ {
inline constexpr /* unspecified */ swap = /* unspecified */;
}
(customization point object)
Call signature
template< class T, class U >
constexpr void ranges::swap ( T&& t, U&& u ) noexcept(/* see below */);
(since C++20)
constexpr void ranges::swap ( T&& t, U&& u ) noexcept(/* see below */);
Exchanges the values referenced by t and u.
ranges::swap (t, u) is expression-equivalent to:
- (void)swap(t, u), if t or u has class or enumeration type, and that expression is valid, where the overload resolution is performed within namespace
std::rangeswith the additional candidate template<class T> void swap(T&, T&) = delete;.- 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.
- Otherwise, (void)ranges::swap_ranges (t, u), if t and u are lvalue arrays of equal extent (but possibly different element types) and ranges::swap (*t, *u) is a valid expression, except that noexcept((void)ranges::swap_ranges (t, u)) is equal to noexcept(ranges::swap (*t, *u)).
- Otherwise, an expression which exchanges the referenced values of t and u, if they are both lvalues of the same type
Vthat models std::move_constructible <V> and std::assignable_from <V&, V>.- The result of applying the
noexceptoperator to that expression is equal to std::is_nothrow_move_constructible_v <V> && std::is_nothrow_move_assignable_v <V>. - That expression is a constant expression if
-
Vis a LiteralType, - both t = std::move(u)) and u = std::move(t) are constant subexpressions, and
- the full-expressions of the initializers in the following declarations are constant subexpressions:
- V v1(std::move(t));
- V v2(std::move(u));
-
- The result of applying the
- Otherwise, ranges::swap (t, u) is ill-formed, which can result in substitution failure when ranges::swap (t, u) appears in the immediate context of a template instantiation.
Customization point objects
The name ranges::swap denotes a customization point object, which is a const function object of a literal semiregular class type. See CustomizationPointObject for details.
[edit] Example
Run this code
#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); }
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{ 4 5 6 }, g2{ 1 2 3 }
h1 = 28, h2 = 27[edit] See also
(C++20)
(concept) [edit]