How is std::swap implemented?
Yes, the implementation presented in the question is the classic C++03 one.
A more modern (C++11) implementation of std::swap looks like this:
template<typename T> void swap(T& t1, T& t2) {
T temp = std::move(t1); // or T temp(std::move(t1));
t1 = std::move(t2);
t2 = std::move(temp);
}
This is an improvement over the classic C++03 implementation in terms of resource management because it prevents unneeded copies, etc. It, the C++11 std::swap, requires the type T to be MoveConstructible and MoveAssignable, thus allowing for the implementation and the improvements.
Why would I need to provide a custom implementation?
A custom implementation of swap, for a specific type, is usually advised when your implementation is more efficient or specific than the standard version.
A classic (pre-C++11) example of this is when your class manages a large amount of resources that would be expensive to copy and then delete. Instead, your custom implementation could simply exchange the handles or pointers required to effect the swap.
With the advent of std::move and movable types (and implemented your type as such), circa C++11 and onwards, a lot of the original rationale here is starting to fall away; but nevertheless, if a custom swap would be better than the standard one, implement it.
Generic code will generally be able to use your custom swap if it uses the ADL mechanism appropriately.