namespace - ambiguous call

[Vijay Meena]

I am reading c++ Faq and not able to understand this question
properly. The code is like -

// File - decl.hpp
namespace MySubsystem {
class Fred { };
void myFunc(Fred& x) { }
}

//File - main.cpp

#include "decl.hpp"

void myFunc(MySubsystem::Fred& x) { }

int main() {
MySubsystem::Fred x;
myFunc(x) //<---- ambiguous call to this function
}

When I compile it then compiler generates error as ambiguous call to
function myFunc. My question is - why not the call myFunc inside main
bind to the function defined in global namespace. Why is it ambiguous
call ?


If i change the code as follow -
// File - decl.hpp
namespace MySubsystem {
class Fred { };
void myFunc(void) { }
}


//File - main.cpp

#include "decl.hpp"

void myFunc(void) { }

int main() {
MySubsystem::Fred x;
myFunc() //<---- _NO_ ambiguous call here
}

Then I do not get any problem. Why now it binds to function defined in
global namespace ?

Thanks

 

[Andrey Tarasevich]

I am reading c++ Faq and not able to understand this question
properly. The code is like -

// File - decl.hpp
namespace MySubsystem {
class Fred { };
void myFunc(Fred& x) { }
}

//File - main.cpp

#include "decl.hpp"

void myFunc(MySubsystem::Fred& x) { }

int main() {
MySubsystem::Fred x;
myFunc(x) //<---- ambiguous call to this function
}

When I compile it then compiler generates error as ambiguous call to
function myFunc. My question is - why not the call myFunc inside main
bind to the function defined in global namespace. Why is it ambiguous
call ?

It is called ADL - Argument-Dependent Lookup. When argument type if
defined in a namespace, functions from that namespace are also
considered by name lookup. This is what brought 'MySubsystem::myFunc'
into consideration during name lookup for the call in 'main'. Later
overload resolution compared the candidates and decided that the call is
ambiguous.

If i change the code as follow -
// File - decl.hpp
namespace MySubsystem {
class Fred { };
void myFunc(void) { }
}


//File - main.cpp

#include "decl.hpp"

void myFunc(void) { }

int main() {
MySubsystem::Fred x;
myFunc() //<---- _NO_ ambiguous call here
}

Then I do not get any problem. Why now it binds to function defined in
global namespace ?

Now you have no arguments and, therefore, no ADL. Without ADL, the
ordinary name hiding rules the day, which is why there's no ambiguity here.

 

[Noah Roberts]

It is called ADL - Argument-Dependent Lookup.

AKA "Koenig Lookup" - just in case people want to use google.

 

[Laurent Deniau]

I am reading c++ Faq and not able to understand this question
properly. The code is like -

// File - decl.hpp
namespace MySubsystem {
      class Fred { };
      void myFunc(Fred& x) { }

}

//File - main.cpp

#include "decl.hpp"

void myFunc(MySubsystem::Fred& x) { }

int main() {
      MySubsystem::Fred x;
      myFunc(x)   //<---- ambiguous call to this function

}

When I compile it then compiler generates error as ambiguous call to
function myFunc. My question is - why not the call myFunc inside main
bind to the function defined in global namespace. Why is it ambiguous
call ?

If i change the code as follow -
// File - decl.hpp
namespace MySubsystem {
      class Fred { };
      void myFunc(void) { }

}

//File - main.cpp

#include "decl.hpp"

void myFunc(void) { }

int main() {
      MySubsystem::Fred x;
      myFunc()   //<---- _NO_ ambiguous call here

}

Then I do not get any problem. Why now it binds to function defined in
global namespace ?

Thanks

As already mentioned, this is called ADL, or Koenig lookup in the old
days.

http://en.wikipedia.org/wiki/Argument_dependent_name_lookup

This was introduced (from the D&E) to allow code like

std::cout << my_object;

otherwise you would have to write

my_namespace:perator<<(std::cout, my_object);

or import the my_namespace where the operator<< for my_object's class
is defined.

a+, ld.

 

[Andrey Tarasevich]

Now you have no arguments and, therefore, no ADL. Without ADL, the
ordinary name hiding rules the day, which is why there's no ambiguity here.

A correction:

More precisely, name hiding plays no role in this case. Without ADL,
members of 'MySubsystem' are simply not considered at all.

 

[Vijay Meena]

Thanks all