Forget about the ‘g’ function for a minute and take a look at the following code:

#include
using namespace std;

namespace NS {
class A{};
void f(A) { cout << “f INSIDE called” << endl; }
}

template
void f(T) { cout << “f OUTSIDE is called” << endl; }

int main()
{
NS::A a;
f(a);
}

What is the expected output of this code? We have 2 functions named ‘f’, and in ‘main’ we are only using the namespace ‘std’. A beginning C++ programmer would expect the OUTSIDE version of ‘f’ to be called.

Run the program, output is:
f INSIDE is called

When we call f(A), because the A class resides in the NS namespace, the NS namespace is checked for a function f(A) where a match is found. When we called f(A) we did not specify the NS namespace at all, but thanks to Koenig lookup, the NS namespace version was used.

With regards to the Wikipedia comment, here is the concern of that writer. Let’s say you want to write a special version of std::swap for your class, to make the operation more efficient.

#include
using namespace std;

namespace NS {
class A{};
void f(A) { cout << “f INSIDE called” << endl; }
void swap(A& one,A& two) { cout << “swap INSIDE called”;}
}

template
void f(T) { cout << “f OUTSIDE is called” << endl; }

int main()
{
NS::A a;
f(a);

NS::A b;
swap(a,b);
}

Output is:
f INSIDE called
cout INSIDE called

Thanks to Koenig lookup, your version of ‘swap’ inside of the NS namespace will be called, even though the program is using the std namespace. The output of this program is:

The problem is, some people like to use fully-qualified names. If we take the above code, remove the ‘using namespace std’ and replace all calls to the std namespace, we get:

#include

namespace NS {
class A{};
void f(A) { std::cout << “f INSIDE called” << std::endl; }
void swap(A& one,A& two) { std::cout << “swap INSIDE called” << std::endl;}
}

template
void f(T) { std::cout << “f OUTSIDE is called” << std::endl; }

int main()
{
NS::A a;
f(a);

NS::A b;
std::swap(a,b);
}

Output is:
f INSIDE called

In this case, the fears of the wikipedia writer are realized. We have one programmer who designed the NS namespace and thought that he could slip in an alternate version of the std::swap function call. It works if users of the NS namespace use /unqualified/ calls to swap, but it fails to work if the users of the NS namespace use /fully-qualified/ calls to std::swap.

void foo()
{
int bar = 0;
{
int bar = 10;
cout << bar << endl;
}
}

I think this should print 10 and not 0. This is simple scope resolution and hiding principles right?