Re: template error
* red floyd:
Jerry Coffin wrote:
There are times that a using directive (or at least a using
declaration) can be useful, and there's no real alternative to it.
The canonical example is something like a sort routine. If swap has
been specialized for the type being sorted, we want to use that swap.
If swap has not been specialized for the type, we want to fall back on
using std::swap instead.
We can get that with code something like this:
using std::swap;
template <class T>
void sort(/* ... */) {
// ...
// x1 and x2 are T's.
if (x2 < x1) swap(x1, s2);
// ...
}
Isn't this the one case where the user is allowed to add to std::?
That is, specializing a template in std::? Why not just specialize
std::swap<> for your type T, instead? e.g.:
class my_expensive_to_swap_class {
// ...
public:
void swap(T&);
};
template<>
std::swap<my_expensive_to_swap_class>(
my_expensive_to_swap_class& x,
my_expensive_to_swap_class& y)
{
x.swap(y);
}
// etc....
I agree that this would be nice, and that it's even what one would choose to do
in practice.
But if there's a language lawyer nearby it may be highly provocative.
For the standard (probably through some mishap) only allows specialization of
'std' namespace classes, not routines, and so, perhaps because that arbitrary
restriction appears to be very mysterious and subtle to those who think the
standard must be perfect where it's not obviously self-contradictory, the
established Perfect Standard Code practice is to Not Do That(TM).
Cheers & hth.,
- Alf