Qualified name lookup in a namespace N additionally searches
every element of the inline namespace set of N ([namespace.def]).
If nothing is found,
the results of the lookup are the results of qualified name lookup
in each namespace nominated by a using-directive
that precedes the point of the lookup and
inhabits N or an element of N's inline namespace set.
If a using-directive refers to a namespace
that has already been considered, it does not affect the result.
— end note]
[Example 1: int x;
namespace Y {void f(float);
void h(int);
}namespace Z {void h(double);
}namespace A {usingnamespace Y;
void f(int);
void g(int);
int i;
}namespace B {usingnamespace Z;
void f(char);
int i;
}namespace AB {usingnamespace A;
usingnamespace B;
void g();
}void h(){
AB::g(); // g is declared directly in AB, therefore S is { AB::g() } and AB::g() is chosen
AB::f(1); // f is not declared directly in AB so the rules are applied recursively to A and B;// namespace Y is not searched and Y::f(float) is not considered;// S is { A::f(int), B::f(char) } and overload resolution chooses A::f(int)
AB::f('c'); // as above but resolution chooses B::f(char)
AB::x++; // x is not declared directly in AB, and is not declared in A or B, so the rules// are applied recursively to Y and Z, S is { } so the program is ill-formed
AB::i++; // i is not declared directly in AB so the rules are applied recursively to A and B,// S is { A::i, B::i } so the use is ambiguous and the program is ill-formed
AB::h(16.8); // h is not declared directly in AB and not declared directly in A or B so the rules// are applied recursively to Y and Z, S is { Y::h(int), Z::h(double) } and// overload resolution chooses Z::h(double)} — end example]
Because each referenced namespace is searched at most once, the
following is well-defined:
namespace B {int b;
}namespace A {usingnamespace B;
int a;
}namespace B {usingnamespace A;
}void f(){
A::a++; // OK, a declared directly in A, S is { A::a }
B::a++; // OK, both A and B searched (once), S is { A::a }
A::b++; // OK, both A and B searched (once), S is { B::b }
B::b++; // OK, b declared directly in B, S is { B::b }}
Class and enumeration declarations are not discarded
because of other declarations found in other searches.
— end note]
[Example 4: namespace A {struct x {};
int x;
int y;
}namespace B {struct y {};
}namespace C {usingnamespace A;
usingnamespace B;
int i = C::x; // OK, A::x (of type int)int j = C::y; // ambiguous, A::y or B::y} — end example]