std::swappable, std::swappable_with

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

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)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Concepts library

Core language concepts same_as (C++20) derived_from (C++20) convertible_to (C++20) common_reference_with (C++20) common_with (C++20) integral (C++20) signed_integral (C++20) unsigned_integral (C++20) floating_point (C++20) swappableswappable_with (C++20)(C++20) destructible (C++20) constructible_from (C++20) default_initializable (C++20)   move_constructible (C++20) copy_constructible (C++20) assignable_from (C++20)

Comparison concepts equality_comparableequality_comparable_with (C++20)(C++20) totally_orderedtotally_ordered_with (C++20)(C++20) Object concepts movable (C++20) copyable (C++20) semiregular (C++20) regular (C++20) Callable concepts invocableregular_invocable (C++20)(C++20) predicate (C++20) relation (C++20) equivalence_relation (C++20) strict_weak_order (C++20)

Exposition-only concepts boolean-testable  (C++20)

 

Defined in header <concepts>
template< class T > concept swappable =   requires(T& a, T& b) {     ranges::swap(a, b);   };	(1)	(since C++20)
template< class T, class U > concept swappable_with =   std::common_reference_with<     const std::remove_reference_t<T>&,     const std::remove_reference_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));   };	(2)	(since C++20)

The concept swappable<T> specifies that lvalues of type T are swappable.

The concept swappable_with<T, U> specifies that expressions of the type and value category encoded by T and U are swappable with each other. swappable_with<T, U> is satisfied only if a call to ranges::swap(t, u) exchanges the value of t and u, that is, given distinct objects t2 equal to t and u2 equal to u, after evaluating either ranges::swap(t, u) or ranges::swap(u, t), t2 is equal to u and u2 is equal to t.

Equality preservation

Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).