template<class T>
void swap(T& a, T& b)
// "perfect swap" (almost)
{
T tmp {static_cast<T&&>(a)}; // the initialization may write to a
a = static_cast<T&&>(b);
// the assignment may write to b
b = static_cast<T&&>(tmp); // the assignment may write to tmp
}

The result value of static_cast<T&&>(x) is an rvalue of type T&& for x . An operation that is optimized for rvalues can now use its optimization for x . In particular, if a type T has a move constructor (§3.3.2, §17.5.2) or a move assignment, it will be used.

The use of static_cast in swap() is a bit verbose and slightly prone to mistyping, so the standard
library provides a move() function: move(x) means static_cast<X&&>(x) where X is the type of x .
Given that, we can clean up the definition of swap() a bit:

template<class T>
void swap(T& a, T& b)// "perfect swap" (almost)
{
T tmp {move(a)};// move from a
a = move(b);// move from b
b = move(tmp);// move from tmp
}

In contrast to the original swap() , this latest version need not make any copies; it will use move
operations whenever possible.
Since move(x) does not move x (it simply produces an rvalue reference to x ), it would have been
better if move() had been called rval() , but by now move() has been used for years.