Global namespace undefined ambiguity vs. nested namespace undefined ambiguity
Consider the following two pieces of code:
#include <iostream>
namespace
{
bool foo = false;
}
bool foo = true;
int main()
{
std::cout << foo << std::endl;
}
#include <iostream>
namespace A
{
namespace
{
bool foo = false;
}
bool foo = true;
}
int main()
{
std::cout << A::foo << std::endl;
}
In Snippet A , foo
Usage internally is int main()
ambiguous, while Snippet B is not. Why is this so?
Related: Undefined Region of Undefined Space
source to share
The behavior of unnamed namespaces is specified in section 7.3.1.1 [namespace.unnamed] / p1:
An unnamed-namespace definition behaves as if it had been replaced with
inline_opt namespace unique { /* empty body */ } using namespace unique ; namespace unique { namespace-body }
where
inline
appears if and only when it appears in the unnamed-namespace-definition, all occurrencesunique
in the translation block are replaced with the same identifier, and this identifier is different from all other identifiers in the entire program.
In particular, note that declarations within an unnamed namespace are made visible in the surrounding scope using a pointer directive using namespace unique;
.
In Snippet A, foo
is unqualified, so the compiler looks for unqualified names (§3.4.1 [basic.lookup.unqual]). Here is paragraph 2 of sub-clause:
2 Declarations from the namespace assigned with the using directive are made visible in the namespace that includes the using directive; see 7.3.4. For the purposes of the unqualified name validation rules described in 3.4.1, declarations from a namespace designated by a using-directive are considered members of that enclosing namespace.
Therefore, an unqualified name lookup finds both declarations foo
and the name is ambiguous.
In snippet B, A::foo
is qualified, so name lookup rules apply. Because A
is a namespace, the applicable subclause is §3.4.3.2 [namespace.qual]. In this case, the rule is specified in paragraph 2 of this subsection:
For a namespace
X
and a name, them
set for searching by namesS(X,m)
is defined as follows: letS'(X,m)
be the set of all declarationsm
inX
and the built-in set of namespacesX
(7.3.1). IfS'(X,m)
not empty,S(X,m)
-S'(X,m)
; otherwise, itS(X,m)
is the unionS(Ni,m)
for all namespacesNi
assigned by directives inX
and its built-in namespace.
In other words, qualified name lookup considers namespaces assigned by directives only if the name is not found in the specified namespace and in its built-in namespace. Here, the name foo
is in the namespace A
, so the unnamed namespace assigned with the using directive is not considered and there is no ambiguity.
If you write ::foo
instead foo
in snippet A, then qualified search rules will apply instead, in which case there will be no ambiguity.
source to share