[Example 1: class A { public: static int n; }; int main() { int A; A::n = 42; A b; } template<int> struct B : A {}; namespace N { template<int> void B(); int f() { return B<0>::n; } } — end example]

A qualified name is

• a member-qualified name or
• the terminal name of
  • a qualified-id,
  • a using-declarator,
  • a typename-specifier,
  • a qualified-namespace-specifier, or
  • a nested-name-specifier, reflection-name, elaborated-type-specifier, or class-or-decltype that has a nested-name-specifier ([expr.prim.id.qual]).

[Note 1:

When parsing a class member access, the name following the -> or . is a qualified name even though it is not yet known of which kind.

— end note]

[Example 2:

In N::C::m.Base::f() Base is a member-qualified name; the other qualified names are C, m, and f.

— end example]

[Note 2:

During lookup for a template specialization, no names are dependent.

— end note]

[Example 3: int f(); struct A { int B, C; template<int> using D = void; using T = void; void f(); }; using B = A; template<int> using C = A; template<int> using D = A; template<int> using X = A; template<class T> void g(T *p) { p->X<0>::f(); p->template X<0>::f(); p->B::f(); p->template C<0>::f(); p->template D<0>::f(); p->T::f(); } template void g(A*); — end example]

If a qualified name Q follows a ~:

• If Q is a member-qualified name, it undergoes unqualified lookup as well as qualified lookup.

• If N has another nested-name-specifier S, Q is looked up as if its lookup context were that nominated by S.

• Otherwise, if the terminal name of N is a member-qualified name M, Q is looked up as if ~Q appeared in place of M (as above).

• Otherwise, Q undergoes unqualified lookup.

• Each lookup for Q considers only types (if Q is not followed by a <) and templates whose specializations are types.

  If it finds nothing or is ambiguous, it is discarded.

• The type-name that is or contains Q shall refer to its (original) lookup context (ignoring cv-qualification) under the interpretation established by at least one (successful) lookup performed.

[Example 4: struct C { typedef int I; }; typedef int I1, I2; extern int* p; extern int* q; void f() { p->C::I::~I(); q->I1::~I2(); } struct A { ~A(); }; typedef A AB; int main() { AB* p; p->AB::~AB(); } — end example]

In a lookup for a qualified name N whose lookup context is a class C in which function names are not ignored,15

• if the search finds the injected-class-name of C ([class.pre]), or
• if N is dependent and is the terminal name of a using-declarator ([namespace.udecl]) that names a constructor,

N is instead considered to name the constructor of class C.

[Example 1: struct A { A(); }; struct B: public A { B(); }; A::A() { } B::B() { } B::A ba; A::A a; struct A::A a2; — end example]

[Note 1:

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 { using namespace Y; void f(int); void g(int); int i; } namespace B { using namespace Z; void f(char); int i; } namespace AB { using namespace A; using namespace B; void g(); } void h() { AB::g(); AB::f(1); AB::f('c'); AB::x++; AB::i++; AB::h(16.8); } — end example]

[Example 2: namespace A { int a; } namespace B { using namespace A; } namespace C { using namespace A; } namespace BC { using namespace B; using namespace C; } void f() { BC::a++; } namespace D { using A::a; } namespace BD { using namespace B; using namespace D; } void g() { BD::a++; } — end example]

[Note 3:

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 { using namespace A; using namespace B; int i = C::x; int j = C::y; } — end example]