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

Files changed (1) hide show

tmp/tmpc298zfy4/{from.md → to.md} +206 -96

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

@@ -1,29 +1,47 @@
 ### The `using` declaration <a id="namespace.udecl">[[namespace.udecl]]</a>
-A *using-declaration* introduces a name into the declarative region in
-which the *using-declaration* appears.
 ``` bnf
 using-declaration:
-    'using typename'ₒₚₜ nested-name-specifier unqualified-id ';'
-    'using ::' unqualified-id ';'
 ```
-The member name specified in a *using-declaration* is declared in the
-declarative region in which the *using-declaration* appears. Only the
-specified name is so declared; specifying an enumeration name in a
-*using-declaration* does not declare its enumerators in the
-*using-declaration*’s declarative region. If a *using-declaration* names
-a constructor ([[class.qual]]), it implicitly declares a set of
-constructors in the class in which the *using-declaration* appears (
-[[class.inhctor]]); otherwise the name specified in a
-*using-declaration* is a synonym for a set of declarations in another
-namespace or class.
 Every *using-declaration* is a *declaration* and a *member-declaration*
-and so can be used in a class definition.
 ``` cpp
 struct B {
   void f(char);
   void g(char);
@@ -36,16 +54,32 @@ struct D : B {
   void f(int) { f('c'); }       // calls B::f(char)
   void g(int) { g('c'); }       // recursively calls D::g(int)
 };
 ```
-In a *using-declaration* used as a *member-declaration*, the
-*nested-name-specifier* shall name a base class of the class being
-defined. If such a *using-declaration* names a constructor, the
-*nested-name-specifier* shall name a direct base class of the class
-being defined; otherwise it introduces the set of declarations found by
-member name lookup ([[class.member.lookup]],  [[class.qual]]).
 ``` cpp
 class C {
   int g();
 };
@@ -56,25 +90,30 @@ class D2 : public B {
   using B::x;                   // OK: x is a union member of base B
   using C::g;                   // error: C isn't a base of D2
 };
 ```
-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]]). If an assignment operator brought from a base
-class into a derived class scope has the signature of a copy/move
-assignment operator for the derived class ([[class.copy]]), the
 *using-declaration* does not by itself suppress the implicit declaration
-of the derived class assignment operator; the copy/move assignment
-operator from the base class is hidden or overridden by the
-implicitly-declared copy/move assignment operator of the derived class,
-as described below.
 A *using-declaration* shall not name a *template-id*.
 ``` cpp
 struct A {
   template <class T> void f(T);
   template <class T> struct X { };
 };
@@ -82,34 +121,39 @@ struct B : A {
   using A::f<double>;           // ill-formed
   using A::X<int>;              // ill-formed
 };
 ```
 A *using-declaration* shall not name a namespace.
 A *using-declaration* shall not name a scoped enumerator.
-A *using-declaration* for a class member shall be a
 *member-declaration*.
 ``` cpp
 struct X {
   int i;
   static int s;
 };
 void f() {
-  using X::i; // error: X::i is a class member
- // and this is not a member declaration.
-  using X::s;       // error: X::s is a class member
-                    // and this is not a member declaration.
 }
 ```
 Members declared by a *using-declaration* can be referred to by explicit
-qualification just like other member names ([[namespace.qual]]). In a
-*using-declaration*, a prefix `::` refers to the global namespace.
 ``` cpp
 void f();
 namespace A {
@@ -126,78 +170,83 @@ void h()
   X::f();                       // calls ::f
   X::g();                       // calls A::g
 }
 ```
 A *using-declaration* is a *declaration* and can therefore be used
 repeatedly where (and only where) multiple declarations are allowed.
 ``` cpp
 namespace A {
   int i;
 }
 namespace A1 {
-  using A::i;
-  using A::i;       // OK: double declaration
-}
-void f() {
-  using A::i;
-  using A::i;       // error: double declaration
 }
 struct B {
   int i;
 };
 struct X : B {
-  using B::i;
-  using B::i;       // error: double member declaration
 };
 ```
-Members added to the namespace after the *using-declaration* 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.
 ``` cpp
 namespace A {
   void f(int);
 }
-using A::f;         // f is a synonym for A::f;
-                    // that is, for A::f(int).
 namespace A {
   void f(char);
 }
 void foo() {
-  f('a');           // calls f(int),
-}                   // even though f(char) exists.
 void bar() {
-  using A::f;       // f is a synonym for A::f;
-                    // that is, for A::f(int) and A::f(char).
   f('a');           // calls f(char)
 }
 ```
-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]]).
 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.
 ``` cpp
 namespace A {
   int x;
 }
@@ -224,22 +273,29 @@ void func() {
   x = 99;           // assigns to A::x
   struct x x1;      // x1 has class type B::x
 }
 ```
 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. 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.
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
 }
@@ -256,17 +312,23 @@ void h() {
   f(1);             // error: ambiguous: B::f(int) or C::f(int)?
   void f(int);      // error: f(int) conflicts with C::f(int) and B::f(int)
 }
 ```
-When a *using-declaration* brings names from a base class into a derived
-class scope, 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). For *using-declaration*s that name a constructor,
-see  [[class.inhctor]].
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
@@ -290,32 +352,70 @@ void k(D* p)
   p->f(1);          // calls D::f(int)
   p->f('a');        // calls B::f(char)
   p->g(1);          // calls B::g(int)
   p->g('a');        // calls D::g(char)
 }
 ```
-For the purpose of overload resolution, the functions which are
-introduced by a *using-declaration* into a derived class will be 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.
-The access rules for inheriting constructors are specified in
-[[class.inhctor]]; otherwise all instances of the name mentioned in a
-*using-declaration* shall be accessible. In particular, if a derived
-class uses a *using-declaration* to access a member of a base class, the
-member name shall be accessible. 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-declaration* shall be visible in the
-scope of at least one of the direct base classes of the class where the
-*using-declaration* is specified. Because a *using-declaration*
-designates a base class member (and not a member subobject or a member
-function of a base class subobject), a *using-declaration* cannot be
-used to resolve inherited member ambiguities. For example,
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
@@ -326,18 +426,26 @@ struct C : A {
 struct D : B, C {
   using C::x;
   int x(double);
 };
 int f(D* d) {
-  return d->x();    // ambiguous: B::x or C::x
 }
 ```
-The alias created by the *using-declaration* has the usual accessibility
-for a *member-declaration*. A *using-declaration* that names a
-constructor does not create aliases; see  [[class.inhctor]] for the
-pertinent accessibility rules.
 ``` cpp
 class A {
 private:
     void f(char);
@@ -352,9 +460,11 @@ class B : public A {
 public:
   using A::g;       // B::g is a public synonym for A::g
 };
 ```
-If a *using-declaration* 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* [^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
+below. If the *using-declarator* does not name a constructor, the
+*unqualified-id* is declared in the declarative region in which the
+*using-declaration* appears as a synonym for each declaration introduced
+by the *using-declarator*.
+[*Note 1*: Only the specified name is so declared; specifying an
+enumeration name in a *using-declaration* does not declare its
+enumerators in the *using-declaration*'s declarative
+region. — *end note*]
+If the *using-declarator* names a constructor, it declares that the
+class *inherits* the set of constructor declarations introduced by the
+*using-declarator* from the nominated base class.
 Every *using-declaration* is a *declaration* and a *member-declaration*
+and can therefore be used in a class definition.
+[*Example 1*:
 ``` cpp
 struct B {
   void f(char);
   void g(char);
   void f(int) { f('c'); }       // calls B::f(char)
   void g(int) { g('c'); }       // recursively calls D::g(int)
 };
 ```
+— *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...;
+};
+X<B, D> x;                      // OK: B::g and D::g introduced
+```
+— *end example*]
+[*Example 3*:
 ``` cpp
 class C {
   int g();
 };
   using B::x;                   // OK: x is a union member of base B
   using C::g;                   // error: C isn't a base of D2
 };
 ```
+— *end example*]
+[*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 { };
 };
   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;
 };
 void f() {
+  using X::i; // error: X::i is a class member and this is not a member declaration.
+  using X::s;                   // error: X::s is a class member and this is not a member declaration.
 }
 ```
+— *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 {
   X::f();                       // calls ::f
   X::g();                       // calls A::g
 }
 ```
+— *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;
 }
 namespace A1 {
+  using A::i, A::i;             // OK: double declaration
 }
 struct B {
   int i;
 };
 struct X : B {
+  using B::i, B::i;             // error: double member declaration
 };
 ```
+— *end example*]
+[*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);
 }
+using A::f;         // f is a synonym for A::f; that is, for A::f(int).
 namespace A {
   void f(char);
 }
 void foo() {
+  f('a');           // calls f(int), even though f(char) exists.
+}
 void bar() {
+  using A::f;       // f is a synonym for A::f; that is, for A::f(int) and A::f(char).
   f('a');           // calls f(char)
 }
 ```
+— *end example*]
+[*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;
 }
   x = 99;           // assigns to A::x
   struct x x1;      // x1 has class type B::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,
 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);
 }
   f(1);             // error: ambiguous: B::f(int) or C::f(int)?
   void f(int);      // error: f(int) conflicts with C::f(int) and B::f(int)
 }
 ```
+— *end example*]
+— *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);
   p->f(1);          // calls D::f(int)
   p->f('a');        // calls B::f(char)
   p->g(1);          // calls B::g(int)
   p->g('a');        // calls D::g(char)
 }
+struct B1 {
+  B1(int);
+};
+struct B2 {
+  B2(int);
+};
+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)
+};
+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*
+to access a member of a base class, the member name shall be accessible.
+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 {
 struct D : B, C {
   using C::x;
   int x(double);
 };
 int f(D* d) {
+  return d->x();    // error: overload resolution selects A::x, but A is an ambiguous base class
 }
 ```
+— *end example*]
+— *end note*]
+A synonym created by a *using-declaration* has the usual accessibility
+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);
 public:
   using A::g;       // B::g is a public synonym for A::g
 };
 ```
+— *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