7.0 KiB
[concept.swappable]
18 Concepts library [concepts]
18.4 Language-related concepts [concepts.lang]
18.4.9 Concept swappable [concept.swappable]
Let t1 and t2 be equality-preserving expressions that denote distinct equal objects of type T, and let u1 and u2 similarly denote distinct equal objects of type U.
[Note 1:
t1 and u1 can denote distinct objects, or the same object.
â end note]
An operationexchanges the values denoted by t1 and u1 if and only if the operation modifies neither t2 nor u2 and:
-
If T and U are the same type, the result of the operation is that t1 equals u2 and u1 equals t2.
-
If T and U are different types and common_reference_with<decltype((t1)), decltype((u1))> is modeled, the result of the operation is that C(t1) equals C(u2) and C(u1) equals C(t2) where C is common_reference_t<decltype((t1)), decltype((u1))>.
The name ranges::swap denotes a customization point object ([customization.point.object]).
The expressionranges::swap(E1, E2) for subexpressions E1 and E2 is expression-equivalent to an expressionS determined as follows:
-
S is (void)swap(E1, E2)192 if E1 or E2 has class or enumeration type ([basic.compound]) and that expression is valid, with overload resolution performed in a context that includes the declarationtemplatevoid swap(T&, T&) = delete; and does not include a declaration of ranges::swap. If the function selected by overload resolution does not exchange the values denoted by E1 and E2, the program is ill-formed, no diagnostic required. [Note 2: This precludes calling unconstrained program-defined overloads of swap. When the deleted overload is viable, program-defined overloads need to be more specialized ([temp.func.order]) to be selected. â end note]
-
Otherwise, if E1 and E2 are lvalues of array types ([basic.compound]) with equal extent and ranges::swap(*E1, *E2) is a valid expression, S is (void)ranges::swap_ranges(E1, E2), except that noexcept(S) is equal to noexcept(ranges::swap(*E1, *E2)).
-
Otherwise, if E1 and E2 are lvalues of the same type T that models move_constructible and assignable_from<T&, T>, S is an expression that exchanges the denoted values. S is a constant expression if
T is a literal type ([basic.types.general]),
both E1 = std::move(E2) and E2 = std::move(E1) are constant subexpressions ([defns.const.subexpr]), and
the full-expressions of the initializers in the declarationsT t1(std::move(E1)); T t2(std::move(E2)); are constant subexpressions.
noexcept(S) is equal to is_nothrow_move_constructible_v && is_nothrow_move_assignable_v.
-
Otherwise, ranges::swap(E1, E2) is ill-formed. [Note 3: This case can result in substitution failure when ranges::swap(E1, E2) appears in the immediate context of a template instantiation. â end note]
[Note 4:
Whenever ranges::swap(E1, E2) is a valid expression, it exchanges the values denoted byE1 and E2 and has type void.
â end note]
template<class T> concept [swappable](#concept:swappable "18.4.9 Concept swappable [concept.swappable]") = requires(T& a, T& b) { ranges::swap(a, b); };
template<class T, class U> concept [swappable_with](#concept:swappable_with "18.4.9 Concept swappable [concept.swappable]") = [common_reference_with](concept.commonref#concept:common_reference_with "18.4.5 Concept common_reference_with [concept.commonref]")<T, U> && requires(T&& t, U&& u) { ranges::swap(std::forward<T>(t), std::forward<T>(t)); ranges::swap(std::forward<U>(u), std::forward<U>(u)); ranges::swap(std::forward<T>(t), std::forward<U>(u)); ranges::swap(std::forward<U>(u), std::forward<T>(t)); };
[Note 5:
The semantics of the swappable and swappable_with concepts are fully defined by the ranges::swap customization point object.
â end note]
[Example 1:
User code can ensure that the evaluation of swap calls is performed in an appropriate context under the various conditions as follows:#include #include #include namespace ranges = std::ranges;
template<class T, std::swappable_with U>void value_swap(T&& t, U&& u) { ranges::swap(std::forward(t), std::forward(u));}template<std::swappable T>void lv_swap(T& t1, T& t2) { ranges::swap(t1, t2);}namespace N {struct A { int m; }; struct Proxy { A* a; Proxy(A& a) : a{&a} {}friend void swap(Proxy x, Proxy y) { ranges::swap(*x.a, *y.a); }}; Proxy proxy(A& a) { return Proxy{ a }; }}int main() {int i = 1, j = 2; lv_swap(i, j); assert(i == 2 && j == 1);
N::A a1 = { 5 }, a2 = { -5 }; value_swap(a1, proxy(a2)); assert(a1.m == -5 && a2.m == 5);}
â end example]
The name swap is used here unqualified.