Re: name lookup question ("gotw 30")
On Jul 27, 12:25 pm, Mayuresh <b166er....@gmail.com> wrote:
Hello,
I looked at this example while trying to understand name lookup :http://www.gotw.ca/gotw/030.htm. (It is also present in this book -
"More exceptional c++")
As per the article, the recursive call to foo() below at line marked
with "//1" should be ambiguous. However, it is not. It always invokes
N2::foo leading to infinite recursion.
The case under discussion:
namespace N1 {
void foo() {
std::cout << "Invoked N1::foo\n";
}
}
namespace N2 {
void foo() {
using namespace N1;
std::cout << "Invoked N2::foo\n";
foo(); //1
}
}
(Note all quotes taken from N2588 - a recent draft for C++0x, but I
doubt this has changed significantly)
7.3.4p2 says:
"""
2 A using-directive specifies that the names in the nominated
namespace can be used in the scope in which the using directive
appears after the using-directive. During unqualified name lookup
(3.4.1), the names appear as if they were declared in the nearest
enclosing namespace which contains both the using-directive and the
nominated namespace. [ Note: in this context, ?contains? means
?contains directly or indirectly?. ?end note ]
"""
Here the "nearest enclosing namespace" is the global namespace, so
N1::foo appears as if it is ::foo, and is hidden by N2::foo. (I think
I've understood this correctly.)
Further, if I replace "using namespace N1" with "using N1::foo" , then
it will call N1::foo . As per the article, this too should be
ambiguous.
7.3.3p1 says
"""
A using-declaration introduces a name into the declarative region in
which the using-declaration appears. <snip> The member name specified
in a using-declaration is declared in the declarative region in which
the using-declaration appears.
"""
So N1::foo is declared as foo in the block scope, and hides N2::foo.
Is it a compiler bug (vs 2008 and gcc 4.1) or am i misunderstanding
the article?
I presume you are referring to the following paragraph in the article:
"""
There is another function with signature f(int), namely the one in
namespace A. If B had written "using namespace A;" or "using A::f;",
then A::f(int) would have been visible as a candidate when looking up
f(int), and the "f(i);" call would have been ambiguous between
A::f(int) and B::f(int). Since B did not bring A::f(int) into scope,
however, only B::f(int) is considered and so the call is unambiguous.
"""
He seems to mean putting the using-directive or using-declaration
directly in namespace B (the equivalent of your namespace N2), which
would certainly be true for the declaration (using A::f) because now
both f's are in the same scope and neither hides the other, but
according to my reading should not happen with the directive (using
namespace A) because then A::f appears as ::f and should be hidden.
Yechezkel Mett
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]