I want to overload function to swap two others types, for example,
type<T>, T* and so on,
but I can't compile the following code at VC 6.0.

The compiler says :
error C2667: 'swap' : none of 2 overload have a best conversion
error C2668: 'swap' : ambiguous call to overloaded function
-------------------------------------------------------------------------------------------------------------
template < typename T >
void swap(T &lhs, T &rhs)
{
// do some thing
}

template < typename T >
void swap(T *lhs, T *rhs)
{
// do some thing
}

template < typename T >
struct type{};

template < typename T >
void swap(type<T> &lhs, type<T> &rhs)
{
// do some thing
}
int main()
{
int *p1,*p2;
type<int> t1, t2;
swap(t1, t2);
swap(p1, p2);

* Ruki:
> I want to overload function to swap two others types, for example,
> type<T>, T* and so on,
> but I can't compile the following code at VC 6.0.
>
> The compiler says :
> error C2667: 'swap' : none of 2 overload have a best conversion
> error C2668: 'swap' : ambiguous call to overloaded function
> -------------------------------------------------------------------------------------------------------------
> template < typename T >
> void swap(T &lhs, T &rhs)
> {
> // do some thing
> }
>
> template < typename T >
> void swap(T *lhs, T *rhs)
> {
> // do some thing
> }
>
> template < typename T >
> struct type{};
>
> template < typename T >
> void swap(type<T> &lhs, type<T> &rhs)
> {
> // do some thing
> }
> int main()
> {
> int *p1,*p2;
> type<int> t1, t2;
> swap(t1, t2);
> swap(p1, p2);


Compiles fine with two modern compilers.

Don't use VC6, it's old.

Don't use the name 'swap', it's used by the standard library.

Don't try to be too subtle, like relying on subtleties of overload resolution.

Why don't you just use std::swap instead of defining your own?


Cheers, & hth.,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

> Alf P. Steinbach:

>Don't use VC6, it's old.
I need compiler compatibility

>Why don't you just use std::swap instead of defining your own?
I also need use std::swap specialization for my own types even if i
use std::swap