call of overloaded function is ambiguous (two function in different scope)

Question

code:

namespace asd {
    class A { };
    void f(A &a) { }
}

void f(asd::A &a) { }

int main() {
    asd::A instance;
    f(instance);
    return 0;
}

error:

D:\>g++ -Wall -std=c++98 -pedantic a.cpp
a.cpp: In function 'int main()':
a.cpp:10:12: error: call of overloaded 'f(asd::A&)' is ambiguous
a.cpp:10:12: note: candidates are:
a.cpp:6:6: note: void f(asd::A&)
a.cpp:3:7: note: void asd::f(asd::A&)

why does the compiler search the function 'f' in namespace asd's scope?
why is this called overloading? this is two different functions.
i would understand the error if the main funcion was like this:

int main() {
    using asd::f;
    asd::A instance;
    f(instance);
    return 0;
}

and i would get an error... but with this i dont...

this situation is same as when i do this?

std::cout << str;
// meaning 1:
std::operator<<(std::cout, str);
// meaning 2:
::operator<<(std::cout, str);

score 1 · Answer 1 · answered Dec 04 '13 at 12:42

1

When you do

using asd::f;

you tell the compiler "when I use the symbol f in the current scope, I actually mean asd::f". That's why it works.

As for the first case, it's because the compiler looks in the scope of the type of instance (that is asd) as well as the global scope. It's called Argument Dependent Lookup.

answered Dec 04 '13 at 12:42

Some programmer dude

400,186
35
402
621

I believe you've meant `using` – zoska Dec 04 '13 at 12:46
but when i dont write "using asd::f;" why does not the complier know which one to call? when i call f(), i call f() and not asd::f() (in a normal situation) – user3065741 Dec 04 '13 at 12:54
oh. i see. it depends on the arguments as well – user3065741 Dec 04 '13 at 12:59

benipalj · Answer 2 · 2013-12-04T13:00:26.380

C++ does an argument dependent lookup. This means if you have an argument of a particular class type for a function, then to find the function the compiler will lookup function name in the namespace containing the argument's type.

In the following code, you have specified instance as variable of class A which is namespace asd

int main() {
    asd::A instance;
    f(instance);
    return 0;
}

Hence it will lookup for f in the asd namespace as well. To resolve this use: ::f(instance); for calling f in global namespace or asd::f(instance); in asd namespace.

This is called koenig lookup. Go to this link, if you want to understand more.

score 1 · Answer 3 · answered Dec 04 '13 at 12:47

why does the compiler search the function 'f' in namespace asd's scope?

Argument-dependent lookup. The argument type A is scoped in asd, so that namespace is also searched for suitable overloads.

why is this called overloading? this is two different functions.

That's exactly what overloading means: two functions with the same name but in different scopes, or taking different parameters.

this situation is same as when i do this?

Yes, it could mean either; but since there is no ::operator<<, there is no ambiguity.

call of overloaded function is ambiguous (two function in different scope)

3 Answers3