[namespace.udecl] - C++17 → C++20

Files changed (1) hide show

tmp/tmpiy0ecdfa/{from.md → to.md} +83 -63

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

@@ -1,24 +1,24 @@
-### The `using` declaration <a id="namespace.udecl">[[namespace.udecl]]</a>
 ``` bnf
 using-declaration:
- 'using' using-declarator-list ';'
 ```
 ``` bnf
 using-declarator-list:
     using-declarator '...'ₒₚₜ
     using-declarator-list ',' using-declarator '...'ₒₚₜ
 ```
 ``` bnf
 using-declarator:
- 'typename'ₒₚₜ nested-name-specifier unqualified-id
 ```
-Each *using-declarator* in a *using-declaration* [^6] introduces a set
 of declarations into the declarative region in which the
 *using-declaration* appears. The set of declarations introduced by the
 *using-declarator* is found by performing qualified name lookup (
 [[basic.lookup.qual]], [[class.member.lookup]]) for the name in the
 *using-declarator*, excluding functions that are hidden as described
@@ -57,17 +57,30 @@ struct D : B {
 ```
 — *end example*]
 In a *using-declaration* used as a *member-declaration*, each
-*using-declarator*'s *nested-name-specifier* shall name a base class of
-the class being defined. If a *using-declarator* names a constructor,
-its *nested-name-specifier* shall name a direct base class of the class
-being defined.
 [*Example 2*:
 ``` cpp
 template <typename... bases>
 struct X : bases... {
   using bases::g...;
 };
@@ -75,11 +88,11 @@ struct X : bases... {
 X<B, D> x;                      // OK: B::g and D::g introduced
 ```
 — *end example*]
-[*Example 3*:
 ``` cpp
 class C {
   int g();
 };
@@ -96,45 +109,44 @@ class D2 : public B {
 [*Note 2*: Since destructors do not have names, a *using-declaration*
 cannot refer to a destructor for a base class. Since specializations of
 member templates for conversion functions are not found by name lookup,
 they are not considered when a *using-declaration* specifies a
-conversion function ([[temp.mem]]). — *end note*]
 If a constructor or assignment operator brought from a base class into a
 derived class has the signature of a copy/move constructor or assignment
-operator for the derived class ([[class.copy]]), the
-*using-declaration* does not by itself suppress the implicit declaration
-of the derived class member; the member from the base class is hidden or
-overridden by the implicitly-declared copy/move constructor or
-assignment operator of the derived class, as described below.
 A *using-declaration* shall not name a *template-id*.
-[*Example 4*:
 ``` cpp
 struct A {
   template <class T> void f(T);
   template <class T> struct X { };
 };
 struct B : A {
-  using A::f<double>;           // ill-formed
-  using A::X<int>;              // ill-formed
 };
 ```
 — *end example*]
 A *using-declaration* shall not name a namespace.
-A *using-declaration* shall not name a scoped enumerator.
-A *using-declaration* that names a class member shall be a
-*member-declaration*.
-[*Example 5*:
 ``` cpp
 struct X {
   int i;
   static int s;
@@ -147,13 +159,13 @@ void f() {
 ```
 — *end example*]
 Members declared by a *using-declaration* can be referred to by explicit
-qualification just like other member names ([[namespace.qual]]).
-[*Example 6*:
 ``` cpp
 void f();
 namespace A {
@@ -175,11 +187,11 @@ void h()
 — *end example*]
 A *using-declaration* is a *declaration* and can therefore be used
 repeatedly where (and only where) multiple declarations are allowed.
-[*Example 7*:
 ``` cpp
 namespace A {
   int i;
 }
@@ -202,15 +214,15 @@ struct X : B {
 [*Note 3*: For a *using-declaration* whose *nested-name-specifier*
 names a namespace, members added to the namespace after the
 *using-declaration* are not in the set of introduced declarations, so
 they are not considered when a use of the name is made. Thus, additional
 overloads added after the *using-declaration* are ignored, but default
-function arguments ([[dcl.fct.default]]), default template arguments (
-[[temp.param]]), and template specializations ([[temp.class.spec]],
 [[temp.expl.spec]]) are considered. — *end note*]
-[*Example 8*:
 ``` cpp
 namespace A {
   void f(int);
 }
@@ -235,17 +247,17 @@ void bar() {
 [*Note 4*: Partial specializations of class templates are found by
 looking up the primary class template and then considering all partial
 specializations of that template. If a *using-declaration* names a class
 template, partial specializations introduced after the
 *using-declaration* are effectively visible because the primary template
-is visible ([[temp.class.spec]]). — *end note*]
 Since a *using-declaration* is a declaration, the restrictions on
-declarations of the same name in the same declarative region (
-[[basic.scope]]) also apply to *using-declaration*s.
-[*Example 9*:
 ``` cpp
 namespace A {
   int x;
 }
@@ -276,25 +288,26 @@ void func() {
 ```
 — *end example*]
 If a function declaration in namespace scope or block scope has the same
-name and the same parameter-type-list ([[dcl.fct]]) as a function
 introduced by a *using-declaration*, and the declarations do not declare
 the same function, the program is ill-formed. If a function template
 declaration in namespace scope has the same name, parameter-type-list,
-return type, and template parameter list as a function template
-introduced by a *using-declaration*, the program is ill-formed.
 [*Note 5*:
 Two *using-declaration*s may introduce functions with the same name and
 the same parameter-type-list. If, for a call to an unqualified function
 name, function overload resolution selects the functions introduced by
 such *using-declaration*s, the function call is ill-formed.
-[*Example 10*:
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
@@ -319,16 +332,17 @@ void h() {
 — *end note*]
 When a *using-declarator* brings declarations from a base class into a
 derived class, member functions and member function templates in the
 derived class override and/or hide member functions and member function
-templates with the same name, parameter-type-list ([[dcl.fct]]),
-cv-qualification, and *ref-qualifier* (if any) in a base class (rather
-than conflicting). Such hidden or overridden declarations are excluded
-from the set of declarations introduced by the *using-declarator*.
-[*Example 11*:
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
@@ -365,11 +379,11 @@ struct B2 {
 struct D1 : B1, B2 {
   using B1::B1;
   using B2::B2;
 };
-D1 d1(0);           // ill-formed: ambiguous
 struct D2 : B1, B2 {
   using B1::B1;
   using B2::B2;
   D2(int);          // OK: D2::D2(int) hides B1::B1(int) and B2::B2(int)
@@ -377,25 +391,31 @@ struct D2 : B1, B2 {
 D2 d2(0);           // calls D2::D2(int)
 ```
 — *end example*]
-For the purpose of overload resolution, the functions that are
-introduced by a *using-declaration* into a derived class are treated as
-though they were members of the derived class. In particular, the
-implicit `this` parameter shall be treated as if it were a pointer to
-the derived class rather than to the base class. This has no effect on
-the type of the function, and in all other respects the function remains
-a member of the base class. Likewise, constructors that are introduced
-by a *using-declaration* are treated as though they were constructors of
-the derived class when looking up the constructors of the derived
-class ([[class.qual]]) or forming a set of overload candidates (
-[[over.match.ctor]], [[over.match.copy]], [[over.match.list]]). If such
-a constructor is selected to perform the initialization of an object of
-class type, all subobjects other than the base class from which the
-constructor originated are implicitly initialized (
-[[class.inhctor.init]]).
 In a *using-declarator* that does not name a constructor, all members of
 the set of introduced declarations shall be accessible. In a
 *using-declarator* that names a constructor, no access check is
 performed. In particular, if a derived class uses a *using-declarator*
@@ -404,18 +424,18 @@ If the name is that of an overloaded member function, then all functions
 named shall be accessible. The base class members mentioned by a
 *using-declarator* shall be visible in the scope of at least one of the
 direct base classes of the class where the *using-declarator* is
 specified.
-[*Note 6*:
 Because a *using-declarator* designates a base class member (and not a
 member subobject or a member function of a base class subobject), a
 *using-declarator* cannot be used to resolve inherited member
 ambiguities.
-[*Example 12*:
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
@@ -441,11 +461,11 @@ for a *member-declaration*. A *using-declarator* that names a
 constructor does not create a synonym; instead, the additional
 constructors are accessible if they would be accessible when used to
 construct an object of the corresponding base class, and the
 accessibility of the *using-declaration* is ignored.
-[*Example 13*:
 ``` cpp
 class A {
 private:
     void f(char);
@@ -463,8 +483,8 @@ public:
 ```
 — *end example*]
 If a *using-declarator* uses the keyword `typename` and specifies a
-dependent name ([[temp.dep]]), the name introduced by the
-*using-declaration* is treated as a *typedef-name* ([[dcl.typedef]]).

+## The `using` declaration <a id="namespace.udecl">[[namespace.udecl]]</a>
 ``` bnf
 using-declaration:
+    using using-declarator-list ';'
 ```
 ``` bnf
 using-declarator-list:
     using-declarator '...'ₒₚₜ
     using-declarator-list ',' using-declarator '...'ₒₚₜ
 ```
 ``` bnf
 using-declarator:
+    typenameₒₚₜ nested-name-specifier unqualified-id
 ```
+Each *using-declarator* in a *using-declaration* [^12] introduces a set
 of declarations into the declarative region in which the
 *using-declaration* appears. The set of declarations introduced by the
 *using-declarator* is found by performing qualified name lookup (
 [[basic.lookup.qual]], [[class.member.lookup]]) for the name in the
 *using-declarator*, excluding functions that are hidden as described
 ```
 — *end example*]
 In a *using-declaration* used as a *member-declaration*, each
+*using-declarator* shall either name an enumerator or have a
+*nested-name-specifier* naming a base class of the class being defined.
 [*Example 2*:
+``` cpp
+enum class button { up, down };
+struct S {
+  using button::up;
+  button b = up;                // OK
+};
+```
+— *end example*]
+If a *using-declarator* names a constructor, its *nested-name-specifier*
+shall name a direct base class of the class being defined.
+[*Example 3*:
 ``` cpp
 template <typename... bases>
 struct X : bases... {
   using bases::g...;
 };
 X<B, D> x;                      // OK: B::g and D::g introduced
 ```
 — *end example*]
+[*Example 4*:
 ``` cpp
 class C {
   int g();
 };
 [*Note 2*: Since destructors do not have names, a *using-declaration*
 cannot refer to a destructor for a base class. Since specializations of
 member templates for conversion functions are not found by name lookup,
 they are not considered when a *using-declaration* specifies a
+conversion function [[temp.mem]]. — *end note*]
 If a constructor or assignment operator brought from a base class into a
 derived class has the signature of a copy/move constructor or assignment
+operator for the derived class ([[class.copy.ctor]],
+[[class.copy.assign]]), the *using-declaration* does not by itself
+suppress the implicit declaration of the derived class member; the
+member from the base class is hidden or overridden by the
+implicitly-declared copy/move constructor or assignment operator of the
+derived class, as described below.
 A *using-declaration* shall not name a *template-id*.
+[*Example 5*:
 ``` cpp
 struct A {
   template <class T> void f(T);
   template <class T> struct X { };
 };
 struct B : A {
+  using A::f<double>;           // error
+  using A::X<int>;              // error
 };
 ```
 — *end example*]
 A *using-declaration* shall not name a namespace.
+A *using-declaration* that names a class member other than an enumerator
+shall be a *member-declaration*.
+[*Example 6*:
 ``` cpp
 struct X {
   int i;
   static int s;
 ```
 — *end example*]
 Members declared by a *using-declaration* can be referred to by explicit
+qualification just like other member names [[namespace.qual]].
+[*Example 7*:
 ``` cpp
 void f();
 namespace A {
 — *end example*]
 A *using-declaration* is a *declaration* and can therefore be used
 repeatedly where (and only where) multiple declarations are allowed.
+[*Example 8*:
 ``` cpp
 namespace A {
   int i;
 }
 [*Note 3*: For a *using-declaration* whose *nested-name-specifier*
 names a namespace, members added to the namespace after the
 *using-declaration* are not in the set of introduced declarations, so
 they are not considered when a use of the name is made. Thus, additional
 overloads added after the *using-declaration* are ignored, but default
+function arguments [[dcl.fct.default]], default template arguments
+[[temp.param]], and template specializations ([[temp.class.spec]],
 [[temp.expl.spec]]) are considered. — *end note*]
+[*Example 9*:
 ``` cpp
 namespace A {
   void f(int);
 }
 [*Note 4*: Partial specializations of class templates are found by
 looking up the primary class template and then considering all partial
 specializations of that template. If a *using-declaration* names a class
 template, partial specializations introduced after the
 *using-declaration* are effectively visible because the primary template
+is visible [[temp.class.spec]]. — *end note*]
 Since a *using-declaration* is a declaration, the restrictions on
+declarations of the same name in the same declarative region
+[[basic.scope]] also apply to *using-declaration*s.
+[*Example 10*:
 ``` cpp
 namespace A {
   int x;
 }
 ```
 — *end example*]
 If a function declaration in namespace scope or block scope has the same
+name and the same parameter-type-list [[dcl.fct]] as a function
 introduced by a *using-declaration*, and the declarations do not declare
 the same function, the program is ill-formed. If a function template
 declaration in namespace scope has the same name, parameter-type-list,
+trailing *requires-clause* (if any), return type, and *template-head*,
+as a function template introduced by a *using-declaration*, the program
+is ill-formed.
 [*Note 5*:
 Two *using-declaration*s may introduce functions with the same name and
 the same parameter-type-list. If, for a call to an unqualified function
 name, function overload resolution selects the functions introduced by
 such *using-declaration*s, the function call is ill-formed.
+[*Example 11*:
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
 — *end note*]
 When a *using-declarator* brings declarations from a base class into a
 derived class, member functions and member function templates in the
 derived class override and/or hide member functions and member function
+templates with the same name, parameter-type-list [[dcl.fct]], trailing
+*requires-clause* (if any), cv-qualification, and *ref-qualifier* (if
+any), in a base class (rather than conflicting). Such hidden or
+overridden declarations are excluded from the set of declarations
+introduced by the *using-declarator*.
+[*Example 12*:
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
 struct D1 : B1, B2 {
   using B1::B1;
   using B2::B2;
 };
+D1 d1(0);           // error: ambiguous
 struct D2 : B1, B2 {
   using B1::B1;
   using B2::B2;
   D2(int);          // OK: D2::D2(int) hides B1::B1(int) and B2::B2(int)
 D2 d2(0);           // calls D2::D2(int)
 ```
 — *end example*]
+[*Note 6*: For the purpose of forming a set of candidates during
+overload resolution, the functions that are introduced by a
+*using-declaration* into a derived class are treated as though they were
+members of the derived class [[class.member.lookup]]. In particular, the
+implicit object parameter is treated as if it were a reference to the
+derived class rather than to the base class [[over.match.funcs]]. This
+has no effect on the type of the function, and in all other respects the
+function remains a member of the base class. — *end note*]
+Constructors that are introduced by a *using-declaration* are treated as
+though they were constructors of the derived class when looking up the
+constructors of the derived class [[class.qual]] or forming a set of
+overload candidates ([[over.match.ctor]], [[over.match.copy]],
+[[over.match.list]]).
+[*Note 7*: If such a constructor is selected to perform the
+initialization of an object of class type, all subobjects other than the
+base class from which the constructor originated are implicitly
+initialized [[class.inhctor.init]]. A constructor of a derived class is
+sometimes preferred to a constructor of a base class if they would
+otherwise be ambiguous [[over.match.best]]. — *end note*]
 In a *using-declarator* that does not name a constructor, all members of
 the set of introduced declarations shall be accessible. In a
 *using-declarator* that names a constructor, no access check is
 performed. In particular, if a derived class uses a *using-declarator*
 named shall be accessible. The base class members mentioned by a
 *using-declarator* shall be visible in the scope of at least one of the
 direct base classes of the class where the *using-declarator* is
 specified.
+[*Note 8*:
 Because a *using-declarator* designates a base class member (and not a
 member subobject or a member function of a base class subobject), a
 *using-declarator* cannot be used to resolve inherited member
 ambiguities.
+[*Example 13*:
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
 constructor does not create a synonym; instead, the additional
 constructors are accessible if they would be accessible when used to
 construct an object of the corresponding base class, and the
 accessibility of the *using-declaration* is ignored.
+[*Example 14*:
 ``` cpp
 class A {
 private:
     void f(char);
 ```
 — *end example*]
 If a *using-declarator* uses the keyword `typename` and specifies a
+dependent name [[temp.dep]], the name introduced by the
+*using-declaration* is treated as a *typedef-name* [[dcl.typedef]].

Diff to HTML by rtfpessoa