[temp.local] - C++20 → C++23

Files changed (1) hide show

tmp/tmpn5s9wr0o/{from.md → to.md} +34 -71

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

@@ -6,18 +6,18 @@ as a *template-name* or a *type-name*. When it is used with a
 *template-argument-list*, as a *template-argument* for a template
 *template-parameter*, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
 is a *template-name* that refers to the class template itself.
 Otherwise, it is a *type-name* equivalent to the *template-name*
-followed by the *template-parameter*s of the class template enclosed in
-`<>`.
-Within the scope of a class template specialization or partial
-specialization, when the injected-class-name is used as a *type-name*,
-it is equivalent to the *template-name* followed by the
-*template-argument*s of the class template specialization or partial
-specialization enclosed in `<>`.
 [*Example 1*:
 ``` cpp
 template<template<class> class T> class A { };
@@ -34,11 +34,11 @@ template<> class Y<int> {
 — *end example*]
 The injected-class-name of a class template or class template
 specialization can be used as either a *template-name* or a *type-name*
-wherever it is in scope.
 [*Example 2*:
 ``` cpp
 template <class T> struct Base {
@@ -47,12 +47,12 @@ template <class T> struct Base {
 template <class T> struct Derived: public Base<T> {
   typename Derived::Base* p;            // meaning Derived::Base<T>
 };
-template<class T, template<class> class U = T::template Base> struct Third { };
-Third<Derived<int> > t;                 // OK: default argument uses injected-class-name as a template
 ```
 — *end example*]
 A lookup that finds an injected-class-name [[class.member.lookup]] can
@@ -90,96 +90,59 @@ template<class T> class X {
 };
 ```
 — *end example*]
-The name of a *template-parameter* shall not be redeclared within its
-scope (including nested scopes). A *template-parameter* shall not have
-the same name as the template name.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
-  int T;                                // error: template-parameter redeclared
   void f() {
-    char T;                             // error: template-parameter redeclared
   }
 };
-template<class X> class X;              // error: template-parameter redeclared
 ```
 — *end example*]
-In the definition of a member of a class template that appears outside
-of the class template definition, the name of a member of the class
-template hides the name of a *template-parameter* of any enclosing class
-templates (but not a *template-parameter* of the member if the member is
-a class or function template).
 [*Example 6*:
 ``` cpp
-template<class T> struct A {
-  struct B { ... };
     typedef void C;
     void f();
     template<class U> void g(U);
   };
-template<class B> void A<B>::f() {
-  B b;              // A's B, not the template parameter
 }
-template<class B> template<class C> void A<B>::g(C) {
- B b; // A's B, not the template parameter
-  C c;              // the template parameter C, not A's C
 }
-```
-— *end example*]
-In the definition of a member of a class template that appears outside
-of the namespace containing the class template definition, the name of a
-*template-parameter* hides the name of a member of this namespace.
-[*Example 7*:
-``` cpp
-namespace N {
-  class C { };
-  template<class T> class B {
-    void f(T);
-  };
-}
-template<class C> void N::B<C>::f(C) {
-  C b;              // C is the template parameter, not N::C
 }
 ```
 — *end example*]
-In the definition of a class template or in the definition of a member
-of such a template that appears outside of the template definition, for
-each non-dependent base class [[temp.dep.type]], if the name of the base
-class or the name of a member of the base class is the same as the name
-of a *template-parameter*, the base class name or member name hides the
-*template-parameter* name [[basic.scope.hiding]].
-[*Example 8*:
-``` cpp
-struct A {
-  struct B { ... };
-  int a;
-  int Y;
-};
-template<class B, class a> struct X : A {
-  B b;              // A's B
-  a b;              // error: A's a isn't a type name
-};
-```
-— *end example*]

 *template-argument-list*, as a *template-argument* for a template
 *template-parameter*, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
 is a *template-name* that refers to the class template itself.
 Otherwise, it is a *type-name* equivalent to the *template-name*
+followed by the template argument list
+[[temp.decls.general]], [[temp.arg.general]] of the class template
+enclosed in `<>`.
+When the injected-class-name of a class template specialization or
+partial specialization is used as a *type-name*, it is equivalent to the
+*template-name* followed by the *template-argument*s of the class
+template specialization or partial specialization enclosed in `<>`.
 [*Example 1*:
 ``` cpp
 template<template<class> class T> class A { };
 — *end example*]
 The injected-class-name of a class template or class template
 specialization can be used as either a *template-name* or a *type-name*
+wherever it is named.
 [*Example 2*:
 ``` cpp
 template <class T> struct Base {
 template <class T> struct Derived: public Base<T> {
   typename Derived::Base* p;            // meaning Derived::Base<T>
 };
+template<class T, template<class> class U = T::Base> struct Third { };
+Third<Derived<int> > t;                 // OK, default argument uses injected-class-name as a template
 ```
 — *end example*]
 A lookup that finds an injected-class-name [[class.member.lookup]] can
 };
 ```
 — *end example*]
+The name of a *template-parameter* shall not be bound to any following
+declaration whose locus is contained by the scope to which the
+template-parameter belongs.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
+  int T;                                // error: template-parameter hidden
   void f() {
+    char T;                             // error: template-parameter hidden
   }
+  friend void T();                      // OK, no name bound
 };
+template<class X> class X;              // error: hidden by template-parameter
 ```
 — *end example*]
+Unqualified name lookup considers the template parameter scope of a
+*template-declaration* immediately after the outermost scope associated
+with the template declared (even if its parent scope does not contain
+the *template-parameter-list*).
+[*Note 1*: The scope of a class template, including its non-dependent
+base classes [[temp.dep.type]], [[class.member.lookup]], is searched
+before its template parameter scope. — *end note*]
 [*Example 6*:
 ``` cpp
+struct B { };
+namespace N {
+  typedef void V;
+  template<class T> struct A : B {
     typedef void C;
     void f();
     template<class U> void g(U);
   };
 }
+template<class V> void N::A<V>::f() {   // N::V not considered here
+ V v; // V is still the template parameter, not N::V
 }
+template<class B> template<class C> void N::A<B>::g(C) {
+  B b;                                  // B is the base class, not the template parameter
+  C c;                                  // C is the template parameter, not A's C
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa