Koenig Lookup/ Argument -Dependent Lookup

Koenig Lookup/ Argument -Dependent Lookup


lets suppose the following scenario -->


//Trivial namespace for testing purpose
namespace test
{


class A { }; //Empty Class
void f(int x) {  cout<<x; } //simply ouputs the integer value passd
int f(A obj) { cout<<"OBJECT"; } //Prints OBJECT and takes an object of class A


}


int main()
{
//Inside main() i make a simple function call
f(10);
}


Now what will happen is that the compiler will search the global/free functions for 


similar signature, but wont find one because there aint one. The function 
void f(int x) is the namespace test and is inaccesible there until we use 
using namespace test;
Now if i add a function 


int f(int x)
{ cout<<x; }


int main()
{
//Inside main() i make a simple function call
f(10);
}


just before main() i.e in the global region, then the compiler will find a match when 


called through main(). This is all so simple and obvious, isnt it?
 Now a similar case -->


//Trivial namespace for testing purpose
namespace test
{


class A { }; //Empty Class
void f(int x) {  cout<<x; } //simply ouputs the integer value passd
int f(A obj) { cout<<"OBJECT"; } //Prints OBJECT and takes an object of class A


}


int f(test::A obj) { cout<<"ANOTHER OBJECT"; } //Similar to function inside namespace


//but this one is just in global scope


int main()
{
//Inside main() i make a simple function call
test::A obj;
f(obj);
}


Now what will happen in this case. the obvious answer would be that global f() would be 


called and ANOTHER OBJECT will be printed. but heres the truth guyz, the compiler will 


deflect slightly from usual name-lookup and will use another kind of name-lookup because 


the parameter you passed to the function is an object of a class/structure.
This kind of name-lookup is called KOENIG LOOKUP/ARGUMENT DEPENDENT LOOKUP.
and it would lead to an ambiguous call, the compiler would get confused between
test::f(A obj) and global int f(test::A obj)
although theres no using directive used.


The compiler will follow this rule --->


"If the parameter passed to a function is an object of a class/structure then the compiler 


would also include those namespaces in which that class/structure or its object is 


defined."


Well you would be thinking that whats the use of namespaces then, the namespaces are 


still functional and continue to serve their purpose, but this is just one rare case in which 


the compiler crosses the namespace boundary.
This kind of lookup called KOENIG LOOKUP was named after Andrew Koenig who nailed 


its proper definition.