Jerry said:
[ ... ]
As for swapping, I am pretty sure std::swap makes use of type traits
to select the best swapping algorithm for the object in question.
Mostly it uses specialization to do the job. Quite a few things in the
standard library (e.g. containers) are required to provide
specializations of swap.
Actually, those are overloads.
You're also allowed to add a specialization of
swap to namespace std for your own types, when/if that makes sense.
Unfortunately, the issue is a little more complicated (due to lack of
precision and foresight in the standard).
a) As you correctly point out, one is allowed to add _specializations_.
However, one is not allowed to add _overloads_ (at least formally the
standard does not give that license).
Consequently, the correct way to insert a custom swap for your own type
MyType into namespace standard looks suprisingly complicated:
namespace std {
template<>
void swap( MyType & lhs, MyType & rhs ) {
lhs.swap( rhs );
}
}
b) Adding insult to injury, it becomes therefore impossible to provide a
custom swap in namespace std for your own templates. If you do
namespace std {
template < typename T >
void swap ( MyTemplate<T> & lhs, MyTemplate<T> & rhs ) {
lhs.swap( rhs );
}
}
you are just adding overloads. The language does not (yet?) allow for
partial specializations of function templates.
c) When writing your own generic algorithms (which reside outside namespace
std), you have to decide whether to use
std::swap( a, b );
or
swap( a, b ); // use dependent name lookup to find the right swap.
It is unspecified which version the standard library uses, so there is no
clear lead to follow. (Maybe, it is good idea to do
namespace my_stuff {
using std::swap;
...
void some_function ( ... ) {
...
swap( a, b );
...
}
}
which would hopefully use std::swap unless dependent name lookup provides
the better match.)
d) The next version of the standard introduces the swappable concept. To be
swappable, the expression
swap( a, b )
is required to work. Then the algorithms in namespace std will use swap(a,b)
instead of std::swap(a,b) and putting the swap function into the same
namespace as the class / template (relying on dependent name lookup) seems
to be the RightThing(tm) with C++0X.
As of now, making sure that your custom swap will be found no matter what
can become quite a hassle.
Best
Kai-Uwe Bux
