[class.member.lookup] - C++17 → C++20

Files changed (1) hide show

tmp/tmpjqtm0jzu/{from.md → to.md} +20 -19

tmp/tmpjqtm0jzu/{from.md → to.md} RENAMED Viewed

@@ -1,38 +1,38 @@
 ## Member name lookup <a id="class.member.lookup">[[class.member.lookup]]</a>
 Member name lookup determines the meaning of a name (*id-expression*) in
-a class scope ([[basic.scope.class]]). Name lookup can result in an
-*ambiguity*, in which case the program is ill-formed. For an
-*id-expression*, name lookup begins in the class scope of `this`; for a
 *qualified-id*, name lookup begins in the scope of the
 *nested-name-specifier*. Name lookup takes place before access control (
-[[basic.lookup]], Clause  [[class.access]]).
 The following steps define the result of name lookup for a member name
 `f` in a class scope `C`.
 The *lookup set* for `f` in `C`, called S(f,C), consists of two
 component sets: the *declaration set*, a set of members named `f`; and
 the *subobject set*, a set of subobjects where declarations of these
 members (possibly including *using-declaration*s) were found. In the
 declaration set, *using-declaration*s are replaced by the set of
 designated members that are not hidden or overridden by members of the
-derived class ([[namespace.udecl]]), and type declarations (including
 injected-class-names) are replaced by the types they designate. S(f,C)
 is calculated as follows:
 If `C` contains a declaration of the name `f`, the declaration set
 contains every declaration of `f` declared in `C` that satisfies the
 requirements of the language construct in which the lookup occurs.
-[*Note 1*: Looking up a name in an *elaborated-type-specifier* (
-[[basic.lookup.elab]]) or *base-specifier* (Clause  [[class.derived]]),
-for instance, ignores all non-type declarations, while looking up a name
-in a *nested-name-specifier* ([[basic.lookup.qual]]) ignores function,
 variable, and enumerator declarations. As another example, looking up a
-name in a *using-declaration* ([[namespace.udecl]]) includes the
 declaration of a class or enumeration that would ordinarily be hidden by
 another declaration of that name in the same scope. — *end note*]
 If the resulting declaration set is not empty, the subobject set
 contains `C` itself, and calculation is complete.
@@ -83,11 +83,11 @@ S(x,F) is unambiguous because the `A` and `B` base class subobjects of
 first merge step.
 — *end example*]
 If the name of an overloaded function is unambiguously found, overload
-resolution ([[over.match]]) also takes place before access control.
 Ambiguities can often be resolved by qualifying a name with its class
 name.
 [*Example 2*:
@@ -134,11 +134,11 @@ struct D : B, C { };
 void f(D* pd) {
   pd->v++;          // OK: only one v (virtual)
   pd->s++;          // OK: only one s (static)
   int i = pd->e;    // OK: only one e (enumerator)
-  pd->a++;          // error, ambiguous: two a{s} in D
 }
 ```
 — *end example*]
@@ -161,17 +161,18 @@ struct B : virtual V, W {
 struct C : virtual V, W { };
 struct D : B, C { void glorp(); };
 ```
-<a id="fig:name"></a>
-![Name lookup \[fig:name\]](images/figname.svg)
-The names declared in `V` and the left-hand instance of `W` are hidden
-by those in `B`, but the names declared in the right-hand instance of
-`W` are not hidden at all.
 ``` cpp
 void D::glorp() {
   x++;              // OK: B::x hides V::x
   f();              // OK: B::f() hides V::f()
@@ -197,20 +198,20 @@ struct C : A, virtual V { };
 struct D : B, C { };
 void g() {
   D d;
   B* pb = &d;
-  A* pa = &d;       // error, ambiguous: C's A or B's A?
   V* pv = &d;       // OK: only one V subobject
 }
 ```
 — *end example*]
 [*Note 4*: Even if the result of name lookup is unambiguous, use of a
 name found in multiple subobjects might still be ambiguous (
-[[conv.mem]],  [[expr.ref]], [[class.access.base]]). — *end note*]
 [*Example 6*:
 ``` cpp
 struct B1 {

 ## Member name lookup <a id="class.member.lookup">[[class.member.lookup]]</a>
 Member name lookup determines the meaning of a name (*id-expression*) in
+a class scope [[basic.scope.class]]. Name lookup can result in an
+ambiguity, in which case the program is ill-formed. For an
+*unqualified-id*, name lookup begins in the class scope of `this`; for a
 *qualified-id*, name lookup begins in the scope of the
 *nested-name-specifier*. Name lookup takes place before access control (
+[[basic.lookup]], [[class.access]]).
 The following steps define the result of name lookup for a member name
 `f` in a class scope `C`.
 The *lookup set* for `f` in `C`, called S(f,C), consists of two
 component sets: the *declaration set*, a set of members named `f`; and
 the *subobject set*, a set of subobjects where declarations of these
 members (possibly including *using-declaration*s) were found. In the
 declaration set, *using-declaration*s are replaced by the set of
 designated members that are not hidden or overridden by members of the
+derived class [[namespace.udecl]], and type declarations (including
 injected-class-names) are replaced by the types they designate. S(f,C)
 is calculated as follows:
 If `C` contains a declaration of the name `f`, the declaration set
 contains every declaration of `f` declared in `C` that satisfies the
 requirements of the language construct in which the lookup occurs.
+[*Note 1*: Looking up a name in an *elaborated-type-specifier*
+[[basic.lookup.elab]] or *base-specifier* [[class.derived]], for
+instance, ignores all non-type declarations, while looking up a name in
+a *nested-name-specifier* [[basic.lookup.qual]] ignores function,
 variable, and enumerator declarations. As another example, looking up a
+name in a *using-declaration* [[namespace.udecl]] includes the
 declaration of a class or enumeration that would ordinarily be hidden by
 another declaration of that name in the same scope. — *end note*]
 If the resulting declaration set is not empty, the subobject set
 contains `C` itself, and calculation is complete.
 first merge step.
 — *end example*]
 If the name of an overloaded function is unambiguously found, overload
+resolution [[over.match]] also takes place before access control.
 Ambiguities can often be resolved by qualifying a name with its class
 name.
 [*Example 2*:
 void f(D* pd) {
   pd->v++;          // OK: only one v (virtual)
   pd->s++;          // OK: only one s (static)
   int i = pd->e;    // OK: only one e (enumerator)
+  pd->a++;          // error: ambiguous: two a{s} in D
 }
 ```
 — *end example*]
 struct C : virtual V, W { };
 struct D : B, C { void glorp(); };
 ```
+<a id="fig:class.lookup"></a>
+![Name lookup \[fig:class.lookup\]](images/figname.svg)
+As illustrated in Figure [[fig:class.lookup]], the names declared in
+`V` and the left-hand instance of `W` are hidden by those in `B`, but
+the names declared in the right-hand instance of `W` are not hidden at
+all.
 ``` cpp
 void D::glorp() {
   x++;              // OK: B::x hides V::x
   f();              // OK: B::f() hides V::f()
 struct D : B, C { };
 void g() {
   D d;
   B* pb = &d;
+  A* pa = &d;       // error: ambiguous: C's A or B's A?
   V* pv = &d;       // OK: only one V subobject
 }
 ```
 — *end example*]
 [*Note 4*: Even if the result of name lookup is unambiguous, use of a
 name found in multiple subobjects might still be ambiguous (
+[[conv.mem]], [[expr.ref]], [[class.access.base]]). — *end note*]
 [*Example 6*:
 ``` cpp
 struct B1 {

Diff to HTML by rtfpessoa