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

Files changed (1) hide show

tmp/tmpjm8fogjb/{from.md → to.md} +51 -23

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

@@ -22,20 +22,22 @@ 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.
-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. If the resulting
-declaration set is not empty, the subobject set contains `C` itself, and
-calculation is complete.
 Otherwise (i.e., `C` does not contain a declaration of `f` or the
 resulting declaration set is empty), S(f,C) is initially empty. If `C`
 has base classes, calculate the lookup set for `f` in each direct base
 class subobject Bᵢ, and merge each such lookup set S(f,Bᵢ) in turn into
@@ -59,10 +61,12 @@ the intermediate S(f,C):
   declarations and the union of the subobject sets.
 The result of name lookup for `f` in `C` is the declaration set of
 S(f,C). If it is an invalid set, the program is ill-formed.
 ``` cpp
 struct A { int x; };                    // S(x,A) = { { A::x }, { A } }
 struct B { float x; };                  // S(x,B) = { { B::x }, { B } }
 struct C: public A, public B { };       // S(x,C) = { invalid, { A in C, B in C } }
 struct D: public virtual C { };         // S(x,D) = S(x,C)
@@ -72,18 +76,22 @@ int main() {
   F f;
   f.x = 0;                              // OK, lookup finds E::x
 }
 ```
-S(x,F) is unambiguous because the `A` and `B` base subobjects of `D` are
-also base subobjects of `E`, so S(x,D) is discarded in the first merge
-step.
-If the name of an overloaded function is unambiguously found,
-overloading resolution ([[over.match]]) also takes place before access
-control. Ambiguities can often be resolved by qualifying a name with its
-class name.
 ``` cpp
 struct A {
   int f();
 };
@@ -99,14 +107,19 @@ struct B {
 struct C : A, B {
   int f() { return A::f() + B::f(); }
 };
 ```
-A static member, a nested type or an enumerator defined in a base class
-`T` can unambiguously be found even if an object has more than one base
-class subobject of type `T`. Two base class subobjects share the
-non-static member subobjects of their common virtual base classes.
 ``` cpp
 struct V {
   int v;
 };
@@ -125,15 +138,20 @@ void f(D* pd) {
   int i = pd->e;    // OK: only one e (enumerator)
   pd->a++;          // error, ambiguous: two a{s} in D
 }
 ```
-When virtual base classes are used, a hidden declaration can be reached
-along a path through the subobject lattice that does not pass through
-the hiding declaration. This is not an ambiguity. The identical use with
-non-virtual base classes is an ambiguity; in that case there is no
-unique instance of the name that hides all the others.
 ``` cpp
 struct V { int f();  int x; };
 struct W { int g();  int y; };
 struct B : virtual V, W {
@@ -160,15 +178,19 @@ void D::glorp() {
   y++;              // error: B::y and C's W::y
   g();              // error: B::g() and C's W::g()
 }
 ```
 An explicit or implicit conversion from a pointer to or an expression
 designating an object of a derived class to a pointer or reference to
 one of its base classes shall unambiguously refer to a unique object
 representing the base class.
 ``` cpp
 struct V { };
 struct A { };
 struct B : A, virtual V { };
 struct C : A, virtual V { };
@@ -180,13 +202,17 @@ void g() {
   A* pa = &d;       // error, ambiguous: C's A or B's A?
   V* pv = &d;       // OK: only one V subobject
 }
 ```
-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]]).
 ``` cpp
 struct B1 {
   void f();
   static void f(int);
@@ -209,5 +235,7 @@ struct D: I1, I2, B2 {
     int D::* mpD = &D::i;       // Ambiguous conversion
   }
 };
 ```

 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.
 Otherwise (i.e., `C` does not contain a declaration of `f` or the
 resulting declaration set is empty), S(f,C) is initially empty. If `C`
 has base classes, calculate the lookup set for `f` in each direct base
 class subobject Bᵢ, and merge each such lookup set S(f,Bᵢ) in turn into
   declarations and the union of the subobject sets.
 The result of name lookup for `f` in `C` is the declaration set of
 S(f,C). If it is an invalid set, the program is ill-formed.
+[*Example 1*:
 ``` cpp
 struct A { int x; };                    // S(x,A) = { { A::x }, { A } }
 struct B { float x; };                  // S(x,B) = { { B::x }, { B } }
 struct C: public A, public B { };       // S(x,C) = { invalid, { A in C, B in C } }
 struct D: public virtual C { };         // S(x,D) = S(x,C)
   F f;
   f.x = 0;                              // OK, lookup finds E::x
 }
 ```
+S(x,F) is unambiguous because the `A` and `B` base class subobjects of
+`D` are also base class subobjects of `E`, so S(x,D) is discarded in the
+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*:
 ``` cpp
 struct A {
   int f();
 };
 struct C : A, B {
   int f() { return A::f() + B::f(); }
 };
 ```
+— *end example*]
+[*Note 2*: A static member, a nested type or an enumerator defined in a
+base class `T` can unambiguously be found even if an object has more
+than one base class subobject of type `T`. Two base class subobjects
+share the non-static member subobjects of their common virtual base
+classes. — *end note*]
+[*Example 3*:
 ``` cpp
 struct V {
   int v;
 };
   int i = pd->e;    // OK: only one e (enumerator)
   pd->a++;          // error, ambiguous: two a{s} in D
 }
 ```
+— *end example*]
+[*Note 3*:  When virtual base classes are used, a hidden declaration
+can be reached along a path through the subobject lattice that does not
+pass through the hiding declaration. This is not an ambiguity. The
+identical use with non-virtual base classes is an ambiguity; in that
+case there is no unique instance of the name that hides all the
+others. — *end note*]
+[*Example 4*:
 ``` cpp
 struct V { int f();  int x; };
 struct W { int g();  int y; };
 struct B : virtual V, W {
   y++;              // error: B::y and C's W::y
   g();              // error: B::g() and C's W::g()
 }
 ```
+— *end example*]
 An explicit or implicit conversion from a pointer to or an expression
 designating an object of a derived class to a pointer or reference to
 one of its base classes shall unambiguously refer to a unique object
 representing the base class.
+[*Example 5*:
 ``` cpp
 struct V { };
 struct A { };
 struct B : A, virtual V { };
 struct C : A, virtual V { };
   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 {
   void f();
   static void f(int);
     int D::* mpD = &D::i;       // Ambiguous conversion
   }
 };
 ```
+— *end example*]

Diff to HTML by rtfpessoa