C++ strange ambiguous call to overloaded function

Question

First of all, this question is purely of theoretical nature. I am not searching for a solution (I already know it), I am just searching for an explanation.

The following code doesn't compile:

struct foo {};
void a(foo) {}
namespace foobar {
    void a(foo) {}
    void b(foo f) {a(f);}
}
int main() {return 1;}

MSVC++:

1>c:\projects\codetests\main.cpp(7) : error C2668: 'foobar::a' : ambiguous call to overloaded function
1>        c:\projects\codetests\main.cpp(4): could be 'void foobar::a(foo)'
1>        c:\projects\codetests\main.cpp(2): or       'void a(foo)' [found using argument-dependent lookup]
1>        while trying to match the argument list '(foo)'

G++:

main.cpp: In function 'void foobar::b(foo)':
main.cpp:5:20: error: call of overloaded 'a(foo&)' is ambiguous
main.cpp:5:20: note: candidates are:
main.cpp:4:7: note: void foobar::a(foo)
main.cpp:2:6: note: void a(foo)

While this code compiles (MSVC++ and G++):

namespace bar {struct foo {};}
void a(bar::foo) {}
namespace foobar {
    void a(bar::foo) {}
    void b(bar::foo f) {a(f);}
}
int main() {return 1;}

Why is that? What does the namespace around foo change for the compiler here? Is this behaviour defined in the C++-Standard? Is there any other explanation? Thanks.

There were two possible matches in the first case, leading to the error. You removed one of those two possible matches in the second case, removing the error. What's the mystery? — David Schwartz, Apr 12 '13 at 10:36
Whey did I remove one possible match in the second case? There are still ::a(bar::foo) and foobar::a(bar::foo). You see the mystery? — florian, Apr 12 '13 at 10:51

qPCR4vir · Accepted Answer · 2013-04-12T10:57:04.523

'void a(foo)' [found using argument-dependent lookup]

Well, surprisingly MSVC has a very good error explanation:

Following the standard, inside a function the compiler look for symbols in the current namespace and in the namespace where the type of the arguments are defined.

In the first case a is in foobar and in the namespace of the argument type foo: the global namespace, making it ambiguous.

In the second case a is in foobar but not in the namespace of the argument type bar::foo: with is bar.

score 0 · Answer 2 · answered Apr 12 '13 at 10:42

0

There are two symbols a(foo) and compiler can't decide which one to use. Hence you have to explicitly instruct the compiler.

If you want a(foo) of foobar to get invoked then try this,

   void b(foo f) { foobar::a(f); }

if you want global a(foo) then try this,

   void b(foo f) { ::a(f); }

answered Apr 12 '13 at 10:42

Arun

2,087
2
20
33

Yes, I know that. But the question is why does the second example compile and the first one not. The only difference is the namespace around struct foo. – florian Apr 12 '13 at 10:52

C++ strange ambiguous call to overloaded function

2 Answers2