StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PONon-obtrusive way of getting around an argument dependent lookup ambiguity
text
Body
copied!<p>Here's my case:</p> <p>I am trying to use a library that has a type <code>Foo::a</code>, and specifies a <code>Foo::swap</code> as well. Another library that I am consuming has a <code>std::vector<Foo::a></code> instantiation. I am trying to compile this on Windows using Visual Studio 11.0 and notice that the <code>std::vector::swap</code> maps down to <code>_Swap_adl</code> which does an unqualified swap call.</p> <p>This is what gets me into issues with ADL and ambiguous function resolutions. Is there some magic that will allow me to use <code>Foo::swap</code> (heck even <code>std::swap</code> :)), without making some "major" change to the libraries that I am consuming (stuff that is short of removing/renaming swap from Foo, etc)?</p> <p>Edit: Adding a minimal example that captures what is going on and the error. </p> <pre><code>#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; } </code></pre> <p>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 @ <strong><a href="http://pastebin.com/Ztea46aC" rel="nofollow">http://pastebin.com/Ztea46aC</a></strong> 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?</p> <p>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.</p> <pre><code>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; } } </code></pre> <p><strong><a href="http://pastebin.com/sMGDZQBZ" rel="nofollow">http://pastebin.com/sMGDZQBZ</a></strong> is the error log from this attempt.</p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload