Swappable

Any lvalue or rvalue of this type can be swapped with any lvalue or rvalue of some other type, using unqualified function call swap() in the context where both std::swap and the user-defined swap()s are visible.

Requirements

Type U is swappable with type T if, for any object u of type U and any object t of type T,

Many standard library functions (for example, many algorithms) expect their arguments to satisfy Swappable, which means that any time the standard library performs a swap, it uses the equivalent of using std::swap; swap(t, u);.

Typical implementations either.

Notes

It is unspecified if <utility> is actually included when the standard library functions perform the swap, so the user-provided swap() should not expect it to be included.

Example

#include <iostream>
#include <vector>
 
class IntVector {
    std::vector<int> v;
    IntVector& operator=(IntVector); // not assignable
 public:
    void swap(IntVector& other) {
        v.swap(other.v);
    }
};
void swap(IntVector& v1, IntVector& v2) {
    v1.swap(v2);
}
 
int main()
{
    IntVector v1, v2;
//  std::swap(v1, v2); // compiler error! std::swap requires MoveAssignable
    std::iter_swap(&v1, &v2); // OK: library calls unqualified swap()
}