FreeBSD Manual Pages
std::ranges::swap(3) C++ Standard Libary std::ranges::swap(3) NAME std::ranges::swap - std::ranges::swap Synopsis Defined in header <concepts> namespace ranges { inline namespace /* unspecified */ { inline constexpr /* unspecified */ swap = /* (since C++20) unspecified */; (customiza- tion point object) } } Call signature template< class T, class U > 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: 1. (void)swap(t, u), if std::remove_cvref_t<T> or std::re- move_cvref_t<U> are class or enumeration types, and that expression is valid, where the overload resolution is performed within namespace std::ranges with 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. 2. 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(ranges::swap(t, u)) is equal to noexcept(ranges::swap(*t, *u)). 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 lvalues of the same type V that satisfies std::move_constructible<V> and std::assigna- ble_from<V&, V>, in which case noexcept(ranges::swap(t, u)) is equal to std::is_nothrow_move_constructible_v<V> && std::is_nothrow_move_assignable_v<V>. ranges::swap(t, u) is a constant expression if V(std::move(t)), V(std::move(u)), t = std::move(u), and u = std::move(t); are all constant expressions 4. 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. Expression-equivalent Expression e is expression-equivalent to expression f, if * e and f 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 poten- tially-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 dif- ferent 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 inter- changeably. 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 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 See also swappable specifies that a type can be swapped or that two types can be swapped swappable_with with each other (C++20) (concept) swap swaps the values of two objects (function template) http://cppreference.com 2022.07.31 std::ranges::swap(3)
NAME | Synopsis | Example | Output: | See also
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::ranges::swap&sektion=3&manpath=FreeBSD+Ports+15.0>