std::ranges::swap
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
:
- 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.
t
andu
, the program is ill-formed; no diagnostic required. -
- Otherwise, is expression-equivalent to
(void)ranges::swap_ranges(t, u)
except thatnoexcept(ranges::swap(t, u))
is equal tonoexcept(ranges::swap(*t, *u))
, ifT
andU
are lvalue references to array types of equal extent (but possibly different element types) andranges::swap(*t, *u)
is a valid expression; - Otherwise, exchanges the referenced values as if by
V v(std::move(t)); t = std::move(u); u = std::move(v);
, ifT
andU
are both lvalue references toV
for some typeV
that satisfiesstd::move_constructible<V>
andstd::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
andv
swapped are usable in constant evaluation.
- In all other cases, a call to
ranges::swap
is ill-formed, which can result in substitution failure whenranges::swap(t, u)
appears in the immediate context of a template instantiation.
Expression-equivalent
Expression e
is expression-equivalent to expression f
, if.
-
e
andf
have the same effects, and - either both are constant subexpressions or else neither is a constant subexpression, and
- either both are potentially-throwing or else neither is potentially-throwing (i.e.
noexcept(e) == noexcept(f)
).
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
#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
(C++20)
|
specifies that a type can be swapped or that two types can be swapped with each other (concept) |
swaps the values of two objects (function template) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/ranges/swap