Non-obtrusive way of getting around an argument dependent lookup ambiguity - c++

Question

Here's my case:
I am trying to use a library that has a type Foo::a, and specifies a Foo::swap as well. Another library that I am consuming has a std::vector<Foo::a> instantiation. I am trying to compile this on Windows using Visual Studio 11.0 and notice that the std::vector::swap maps down to _Swap_adl which does an unqualified swap call.
This is what gets me into issues with ADL and ambiguous function resolutions. Is there some magic that will allow me to use Foo::swap (heck even std::swap :)), without making some "major" change to the libraries that I am consuming (stuff that is short of removing/renaming swap from Foo, etc)?
Edit:
Adding a minimal example that captures what is going on and the error.
#include <iostream>
#include <vector>
namespace Foo
{
class MyType
{
public:
float dummy;
};
template <class T>
void swap(T& a, T& b)
{
T c(a);
a = b;
b = c;
}
}
using namespace Foo;
class MyClass
{
public:
std::vector<MyType> myStructArr;
};
std::vector<MyType> getMyTypeArray()
{
MyType myType;
std::vector<MyType> myTypeArray;
myTypeArray.push_back(myType);
return myTypeArray;
}
namespace std
{
template <>
void swap<MyType*>(MyType*& a, MyType*& b)
{
MyType* c(a);
a = b;
b = c;
}
template <>
void swap<MyType>(MyType& a, MyType& b)
{
MyType c(a);
a = b;
b = c;
}
}
int main(int argc, char* argv[])
{
MyClass m;
MyType myTypeLocal;
std::vector<MyType> myTypeArrayLocal;
myTypeArrayLocal.push_back(myTypeLocal);
//m.myStructArr = myTypeArrayLocal;
m.myStructArr = getMyTypeArray();
return 0;
}
I won't comment on the efficiency of the code, as its something that I just have to work with, but the error log at # http://pastebin.com/Ztea46aC gives a fair idea of what's going on internally. Is this a compiler specific issue, or is there a deeper learning to be gained from this piece of code?
Edit 2:
I've tried specializing for the particular type in question, but that doesn't resolve the ambiguity. Any pointers on why this is so would be helpful as well.
namespace std
{
template <>
void swap<MyType*>(MyType*& a, MyType*& b)
{
MyType* c(a);
a = b;
b = c;
}
template <>
void swap<MyType>(MyType& a, MyType& b)
{
MyType c(a);
a = b;
b = c;
}
}
http://pastebin.com/sMGDZQBZ is the error log from this attempt.

Answer 1

As the error message says, the function call is ambiguous. There are two versions of swap that could be applied: the one in namespace Foo and the one in namespace std. The first is found by argument-dependent lookup. The second is found because vector is defined in std, so sees std::swap (as designed).
This isn't a situation where one declaration hides another; it is simply a set of possible overloads, so the usual ordering rules for selecting an overloaded function apply. The two versions of swap take the same argument types, so there is no preference for one over the other.

Answer 2

Pete's answer explains the situation. Both templates for swap are equally favoured during the overload resolution steps, so the call is ambiguous - in any context where both namespaces are visible. Specialisation is the correct approach to this problem, however based on your errors you've forgotten to remove the offending template Foo::swap - see here for what your code should look like.
Here's what everything looks like - I just replaced the std namespace with the bar namespace.
#include <iostream>
namespace bar { //std namespace
template<typename T>
void swap(T s, T t){ std::cout << "bar swap\n"; }
template<typename S>
struct vec {
S s;
void error() { swap(s, s); }
};}
namespace foo { //your namespace
struct type {};
/*this template is not allowed/not a good idea because of exactly your problem
template<typename T>
void swap(T s, T t){ std::cout << "foo swap\n"; }
*/
//you will have to rename foo::swap to something like this, and make it call
//specialise std::swap for any types used in std containers, so that they called yuor
//renamed foo::swap
template<typename T>
void swap_proxy(T s, T t){ std::cout << "foo swap (via proxy) \n"; }
}
namespace bar {
template<> void swap(foo::type s, foo::type t) { std::cout << "foo swap\n"; }
}
int main()
{
//instead specialise std::swap with your type
bar::vec<foo::type> myVec;
myVec.error();
std::cout << "Test\n";
operator<<(std::cout, "Test\n");
}
All that said I'll try and cook up a templated alternative - however it will call std::swap in std code (it will make foo::swap a worse alternative, so there will be no ambiguity.
This avoids changing the name of swap, but still changes its definition slightly - although
you shouldn't have to tamper with code inside swap, only code that calls will have to cast as explained
#include <iostream>
namespace bar { //std namespace
template<typename T>
void swap(T s, T t){ std::cout << "bar swap\n"; }
template<typename S>
struct vec {
S s;
void error() { swap(s, s); }
};}
namespace foo { //your namespace
// Include this pattern (The infamous Curiously Recurring Template Pattern) in foo namespace
template<template<class> class Derived, typename t>
struct Base : public t { Base(){} Base(Derived<t> d){} };
template<typename t> struct Derived : public Base<Derived, t> {};
template<class t> using UnWrapped = Base<Derived, t>;
template<class t> using Wrapped = Derived<t>;
//we redefine swap to accept only unwrapped t's - meanwhile
//we use wrapped t's in std::containers
template<typename T>
void swap(UnWrapped<T> s, UnWrapped<T> t){ std::cout << "foo swap\n"; }
struct type {
};
}
int main()
{
//use the wrapped type
typedef foo::Wrapped<foo::type> WrappedType;
typedef foo::UnWrapped<foo::type> UnWrappedType;
bar::vec<WrappedType> myVec;
//this is the function which makes the ambiguous call
myVec.error();
//but instead calls bar::swap
//but -- it calls foo swap outside of bar! - any you didn't
//have to change the name of swap, only alter definition slightly
swap(WrappedType(), WrappedType());
//safe outside of bar
swap(UnWrappedType(), UnWrappedType());
//the following no longer works :/
//swap<foo::type>(foo::type(), foo::type());
//instead, yuo will have to cast to UnWrapped<type>
}