template<class T> void swap(T& left, T&
The template function
allows the values of two variables to be swapped, using argument dependent
lookup to select a specialized swap function if available. If no specialized
swap function is available,
std::swap function requires that the elements
to be swapped are assignable and copy constructible. It is usually implemented
using one copy construction and two assignments - this is often both unnecessarily
restrictive and unnecessarily slow. In addition, where the generic swap implementation
provides only the basic guarantee, specialized swap functions are often able
to provide the no-throw exception guarantee (and it is considered best practice
to do so where possible .
The alternative to using argument dependent lookup in this situation is to
provide a template specialization of
for every type that requires a specialized swap. Although this is legal C++,
no Boost libraries use this method, whereas many Boost libraries provide
specialized swap functions in their own namespaces.
boost::swap also supports swapping built-in arrays.
std::swap originally did not do so, but a request
to add an overload of
for built-in arrays has been accepted by the C++ Standards Committee.
boost::swap provides the same exception guarantee
as the underlying swap function used, with one exception; for an array of
1 and the underlying swap function
T provides the strong
provides only the basic exception guarantee.
swap(T&,T&) is available via argument dependent
exists for T
Several older compilers do not support argument dependent lookup. On these
boost::swap will call
ignoring any specialized swap functions that could be found as a result of
argument dependent lookup.
boost::swap less specialized than
std::swap, thereby allowing the function
to have the name 'swap' without introducing ambiguity
 Scott Meyers, Effective C++ Third Edition, Item 25: "Consider support for a non-throwing swap"