Thread: Call to templated function is ambiguous when using float

A few options come to mind:

A. Declare your function template within your own namespace and call it qualified with the namespace name.

B. Be more careful with your use of using directives and using declarations. In this case it means avoiding using namespace std and/or using std::swap in contexts such that it will allow swap from the std namespace to be called without qualification.

C. Rename your function template so that it won't conflict with swap from the std namespace.

Of course, in production code you should just use std::swap for such types.

Originally Posted by colt

Hello, I have this function:

Code:

template <typename T>
void swap (T& arg1, T& arg2) {
   T& tmp = arg1;
   arg1  = arg2;
   arg2  = tmp;
}

Whilst not related to your actual problem, the temporary should be a T, not a T &.

Originally Posted by colt

The only thing I was calling, was #include <iostream>

However, that header could indirectly include a header that defines std::swap.

Originally Posted by colt

But it is not bad for the performance if the type is of something "big"

The problem is that it is simply incorrect if you're trying to implement a swap. If you make tmp a reference and initialise it to refer to arg1 instead of making it a copy of arg1, then when you assign arg2 to arg1, tmp will also be changed (since it is an alias), so when you assign tmp to arg2, it will have no net effect: you're just assigning a copy of arg2 to arg2, so what you end up with is both arg1 and arg2 having the original value of arg2. That's not a swap.

You should be aware that since the advent of C++11, a generic swap like this (including std::swap) is likely to be implemented using move semantics:

Code:

T tmp = std::move(arg1);
arg1 = std::move(arg2);
arg2 = std::move(tmp);

If moving is more efficient than copying for type T, this would then address the performance issue that you mentioned.