[temp.pre] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpwri8455i/{from.md → to.md} +35 -12

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

@@ -46,10 +46,11 @@ The *declaration* in a *template-declaration* (if any) shall
 - declare or define a function, a class, or a variable, or
 - define a member function, a member class, a member enumeration, or a
   static data member of a class template or of a class nested within a
   class template, or
 - define a member template of a class or class template, or
 - be a *deduction-guide*, or
 - be an *alias-declaration*.
 A *template-declaration* is a *declaration*. A declaration introduced by
 a template declaration of a variable is a *variable template*. A
@@ -88,11 +89,11 @@ be a name.
 [*Note 3*: A class or variable template declaration of a
 *simple-template-id* declares a partial specialization
 [[temp.spec.partial]]. — *end note*]
 In a *template-declaration*, explicit specialization, or explicit
-instantiation the *init-declarator-list* in the declaration shall
 contain at most one declarator. When such a declaration is used to
 declare a class template, no declarator is permitted.
 A specialization (explicit or implicit) of one template is distinct from
 all specializations of any other template. A template, an explicit
@@ -102,24 +103,46 @@ not have C language linkage.
 [*Note 4*: Default arguments for function templates and for member
 functions of class templates are considered definitions for the purpose
 of template instantiation [[temp.decls]] and must obey the
 one-definition rule [[basic.def.odr]]. — *end note*]
-[*Note 5*: A template cannot have the same name as any other name bound
-in the same scope [[basic.scope.scope]], except that a function template
-can share a name with non-template functions [[dcl.fct]] and/or function
-templates [[temp.over]]. Specializations, including partial
-specializations [[temp.spec.partial]], do not reintroduce or bind names.
-Their target scope is the target scope of the primary template, so all
-specializations of a template belong to the same scope as it
-does. — *end note*]
 An entity is *templated* if it is
 - a template,
-- an entity defined [[basic.def]] or created [[class.temporary]] in a
- templated entity,
 - a member of a templated entity,
 - an enumerator for an enumeration that is a templated entity, or
 - the closure type of a *lambda-expression* [[expr.prim.lambda.closure]]
   appearing in the declaration of a templated entity.
@@ -145,11 +168,11 @@ unevaluated operand [[expr.context]].
 The expression in a *requires-clause* uses a restricted grammar to avoid
 ambiguities. Parentheses can be used to specify arbitrary expressions in
 a *requires-clause*.
-[*Example 2*:
 ``` cpp
 template<int N> requires N == sizeof new unsigned short
 int f();            // error: parentheses required around == expression
 ```

 - declare or define a function, a class, or a variable, or
 - define a member function, a member class, a member enumeration, or a
   static data member of a class template or of a class nested within a
   class template, or
 - define a member template of a class or class template, or
+- be a *friend-type-declaration*, or
 - be a *deduction-guide*, or
 - be an *alias-declaration*.
 A *template-declaration* is a *declaration*. A declaration introduced by
 a template declaration of a variable is a *variable template*. A
 [*Note 3*: A class or variable template declaration of a
 *simple-template-id* declares a partial specialization
 [[temp.spec.partial]]. — *end note*]
 In a *template-declaration*, explicit specialization, or explicit
+instantiation, the *init-declarator-list* in the declaration shall
 contain at most one declarator. When such a declaration is used to
 declare a class template, no declarator is permitted.
 A specialization (explicit or implicit) of one template is distinct from
 all specializations of any other template. A template, an explicit
 [*Note 4*: Default arguments for function templates and for member
 functions of class templates are considered definitions for the purpose
 of template instantiation [[temp.decls]] and must obey the
 one-definition rule [[basic.def.odr]]. — *end note*]
+[*Note 5*:
+A template cannot have the same name as any other name bound in the same
+scope [[basic.scope.scope]], except that a function template can share a
+name with *using-declarator*s, a type, non-template functions
+[[dcl.fct]] and/or function templates [[temp.over]]. Specializations,
+including partial specializations [[temp.spec.partial]], do not
+reintroduce or bind names. Their target scope is the target scope of the
+primary template, so all specializations of a template belong to the
+same scope as it does.
+[*Example 2*:
+``` cpp
+void f() {}
+class f {};                                     // OK
+namespace N {
+  void f(int) {}
+}
+using N::f;                                     // OK
+template<typename> void f(long) {}              // #1, OK
+template<typename> void f(long) {}              // error: redefinition of #1
+template<typename> void f(long long) {}         // OK
+template<>         void f<int>(long long) {}    // OK, doesn't bind a name
+```
+— *end example*]
+— *end note*]
 An entity is *templated* if it is
 - a template,
+- an entity defined [[basic.def]] or created [[class.temporary]] within
+ the *compound-statement* of an *expansion-statement* [[stmt.expand]],
+- an entity defined or created in a templated entity,
 - a member of a templated entity,
 - an enumerator for an enumeration that is a templated entity, or
 - the closure type of a *lambda-expression* [[expr.prim.lambda.closure]]
   appearing in the declaration of a templated entity.
 The expression in a *requires-clause* uses a restricted grammar to avoid
 ambiguities. Parentheses can be used to specify arbitrary expressions in
 a *requires-clause*.
+[*Example 3*:
 ``` cpp
 template<int N> requires N == sizeof new unsigned short
 int f();            // error: parentheses required around == expression
 ```

Diff to HTML by rtfpessoa