cppdraft_translate/cppdraft/basic/lookup/qual/general.md

[basic.lookup.qual.general]

6 Basics [basic]

6.5 Name lookup [basic.lookup]

6.5.5 Qualified name lookup [basic.lookup.qual]

6.5.5.1 General [basic.lookup.qual.general]

1

#

Lookup of an identifier followed by a ​::​ scope resolution operator considers only namespaces, types, and templates whose specializations are types.

If a name,template-id,splice-scope-specifier, orcomputed-type-specifier is followed by a ​::​, it shall either be a dependent splice-scope-specifier ([temp.dep.splice]) or it shall designate a namespace, class, enumeration, or dependent type, and the ​::​ is never interpreted as a complete nested-name-specifier.

[Example 1: class A {public:static int n;};int main() {int A; A::n = 42; // OK A b; // error: A does not name a type}template struct B : A {};namespace N {template void B(); int f() {return B<0>::n; // error: N​::​B<0> is not a type}} — end example]

2

#

A member-qualified name is the (unique) component name ([expr.prim.id.unqual]), if any, of

• (2.1)

an unqualified-id or

• (2.2)

a nested-name-specifier of the formtype-name ​::​ or namespace-name ​::​

in the id-expression of a class member access expression ([expr.ref]).

A qualified name is

• (2.3)

a member-qualified name or

• (2.4)

the terminal name of

• (2.4.1)

a qualified-id,

• (2.4.2)

a using-declarator,

• (2.4.3)

a typename-specifier,

• (2.4.4)

a qualified-namespace-specifier, or

• (2.4.5)

a nested-name-specifier,reflection-name,elaborated-type-specifier, orclass-or-decltype that has a nested-name-specifier ([expr.prim.id.qual]).

The lookup context of a member-qualified name is the type of its associated object expression (considered dependent if the object expression is type-dependent).

The lookup context of any other qualified name is the type, template, or namespace nominated by the preceding nested-name-specifier.

[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]

3

#

Qualified name lookup in a class, namespace, or enumeration performs a search of the scope associated with it ([class.member.lookup]) except as specified below.

Unless otherwise specified, a qualified name undergoes qualified name lookup in its lookup context from the point where it appears unless the lookup context either is dependent and is not the current instantiation ([temp.dep.type]) or is not a class or class template.

If nothing is found by qualified lookup for a member-qualified name that is the terminal name ([expr.prim.id.unqual]) of a nested-name-specifier and is not dependent, it undergoes unqualified lookup.

[Note 2:

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

— end note]

[Example 3: int f();struct A {int B, C; template using D = void; using T = void; void f();};using B = A;template using C = A;template using D = A;template using X = A;

templatevoid g(T p) { // as instantiated for g: p->X<0>::f(); // error: A​::​X not found in ((p->X) < 0) > ​::​f() p->template X<0>::f(); // OK, ​::​X found in definition context p->B::f(); // OK, non-type A​::​B ignored p->template C<0>::f(); // error: A​::​C is not a template p->template D<0>::f(); // error: A​::​D<0> is not a class type p->T::f(); // error: A​::​T is not a class type}template void g(A); — end example]

4

#

If a qualified name Q follows a ~:

• (4.1)

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

• (4.2)

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

• (4.3)

  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).

• (4.4)

  Otherwise, Q undergoes unqualified lookup.

• (4.5)

  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.

• (4.6)

  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(); // I is looked up in the scope of C q->I1::~I2(); // I2 is found by unqualified lookup}struct A {~A();};typedef A AB;int main() { AB* p; p->AB::~AB(); // explicitly calls the destructor for A} — end example]