[temp.decls] - C++11 → C++14

Files changed (1) hide show

tmp/tmpks3s1d9w/{from.md → to.md} +91 -50

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

@@ -10,15 +10,17 @@ template<class T1, int I> void sort<T1, I>(T1 data[I]);         // error
 ```
 However, this syntax is allowed in class template partial
 specializations ([[temp.class.spec]]).
-For purposes of name lookup and instantiation, default arguments of
-function templates and default arguments of member functions of class
-templates are considered definitions; each default argument is a
-separate definition which is unrelated to the function template
-definition or to any other default arguments.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
@@ -122,12 +124,12 @@ v1[3] = 7;                      // Array<int>::operator[]()
 v2[3] = dcomplex(7,8);          // Array<dcomplex>::operator[]()
 ```
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
-A class member of a class template may be defined outside the class
-template definition in which it is declared. The class member must be
 defined before its first use that requires an instantiation (
 [[temp.inst]]). For example,
 ``` cpp
 template<class T> struct A {
@@ -138,18 +140,27 @@ template<class T> class A<T>::B { };
 A<int>::B  b2;                  // OK: requires A::B to be defined
 ```
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
-A definition for a static data member may be provided in a namespace
-scope enclosing the definition of the static member’s class template.
 ``` cpp
 template<class T> class X {
   static T s;
 };
 template<class T> T X<T>::s = 0;
 ```
 An explicit specialization of a static data member declared as an array
 of unknown bound can have a different bound from its definition, if any.
@@ -193,27 +204,27 @@ template<class T> struct string {
 template<class T> template<class T2> int string<T>::compare(const T2& s) {
 }
 ```
-A local class shall not have member templates. Access control rules
-(Clause  [[class.access]]) apply to member template names. A destructor
-shall not be a member template. A normal (non-template) member function
-with a given name and type and a member function template of the same
-name, which could be used to generate a specialization of the same type,
-can both be declared in a class. When both exist, a use of that name and
-type refers to the non-template member unless an explicit template
-argument list is supplied.
 ``` cpp
 template <class T> struct A {
   void f(int);
   template <class T2> void f(T2);
 };
-template <> void A<int>::f(int) { }                     // non-template member
-template <> template <> void A<int>::f<>(int) { }       // template member
 int main() {
   A<char> ac;
   ac.f(1);          // non-template
   ac.f('c');        // template
@@ -330,12 +341,13 @@ the following contexts:
     *type-parameter* without the ellipsis.
 - In an *initializer-list* ([[dcl.init]]); the pattern is an
   *initializer-clause*.
 - In a *base-specifier-list* (Clause  [[class.derived]]); the pattern is
   a *base-specifier*.
-- In a *mem-initializer-list* ([[class.base.init]]); the pattern is a
-  *mem-initializer*.
 - In a *template-argument-list* ([[temp.arg]]); the pattern is a
   *template-argument*.
 - In a *dynamic-exception-specification* ([[except.spec]]); the pattern
   is a *type-id*.
 - In an *attribute-list* ([[dcl.attr.grammar]]); the pattern is an
@@ -345,10 +357,15 @@ the following contexts:
 - In a *capture-list* ([[expr.prim.lambda]]); the pattern is a
   *capture*.
 - In a `sizeof...` expression ([[expr.sizeof]]); the pattern is an
   *identifier*.
 ``` cpp
 template<class ... Types> void f(Types ... rest);
 template<class ... Types> void g(Types ... rest) {
   f(&rest ...);     // ``&rest ...'' is a pack expansion; ``&rest'' is its pattern
 }
@@ -392,18 +409,28 @@ template<class ... Args>
 The instantiation of a pack expansion that is not a `sizeof...`
 expression produces a list
 $\mathtt{E}_1, \mathtt{E}_2, ..., \mathtt{E}_N$, where N is the number
 of elements in the pack expansion parameters. Each Eᵢ is generated by
 instantiating the pattern and replacing each pack expansion parameter
-with its ith element. All of the Eᵢ become elements in the enclosing
-list. The variety of list varies with the context: *expression-list*,
-*base-specifier-list*, *template-argument-list*, etc. When N is zero,
-the instantiation of the expansion produces an empty list. Such an
-instantiation does not alter the syntactic interpretation of the
-enclosing construct, even in cases where omitting the list entirely
-would otherwise be ill-formed or would result in an ambiguity in the
-grammar.
 ``` cpp
 template<class... T> struct X : T... { };
 template<class... T> void f(T... values) {
   X<T...> x(values...);
@@ -419,25 +446,25 @@ parameter pack it expands.
 ### Friends <a id="temp.friend">[[temp.friend]]</a>
 A friend of a class or class template can be a function template or
 class template, a specialization of a function template or class
-template, or an ordinary (non-template) function or class. For a friend
-function declaration that is not a template declaration:
 - if the name of the friend is a qualified or unqualified *template-id*,
   the friend declaration refers to a specialization of a function
-  template, otherwise
 - if the name of the friend is a *qualified-id* and a matching
   non-template function is found in the specified class or namespace,
   the friend declaration refers to that function, otherwise,
 - if the name of the friend is a *qualified-id* and a matching function
   template is found in the specified class or namespace, the friend
   declaration refers to the deduced specialization of that function
   template ([[temp.deduct.decl]]), otherwise,
-- the name shall be an *unqualified-id* that declares (or redeclares) an
- ordinary (non-template) function.
 ``` cpp
 template<class T> class task;
 template<class T> task<T>* preempt(task<T>*);
@@ -455,11 +482,11 @@ template<class T> class task {
 Here, each specialization of the `task` class template has the function
 `next_time` as a friend; because `process` does not have explicit
 *template-argument*s, each specialization of the `task` class template
 has an appropriately typed function `process` as a friend, and this
 friend is not a function template specialization; because the friend
-`preempt` has an explicit *template-argument* `<T>`, each specialization
 of the `task` class template has the appropriate specialization of the
 function template `preempt` as a friend; and each specialization of the
 `task` class template has all specializations of the function template
 `func` as friends. Similarly, each specialization of the `task` class
 template has the class template specialization `task<int>` as a friend,
@@ -494,14 +521,14 @@ class X {
 template<class T> struct A { X::Y ab; };            // OK
 template<class T> struct A<T*> { X::Y ab; };        // OK
 ```
 When a function is defined in a friend function declaration in a class
-template, the function is instantiated when the function is odr-used.
-The same restrictions on multiple declarations and definitions that
-apply to non-template function declarations and definitions also apply
-to these implicit definitions.
 A member of a class template may be declared to be a friend of a
 non-template class. In this case, the corresponding member of every
 specialization of the class template is a friend of the class granting
 friendship. For explicit specializations the corresponding member is the
@@ -669,10 +696,12 @@ following restrictions apply:
   int array[5];
   template< int X > class A<X,&array> { };            // error
   ```
 - The argument list of the specialization shall not be identical to the
   implicit argument list of the primary template.
 - The template parameter list of a specialization shall not contain
   default template argument values.[^4]
 - An argument shall not contain an unexpanded parameter pack. If an
   argument is a pack expansion ([[temp.variadic]]), it shall be the
   last argument in the template argument list.
@@ -837,12 +866,12 @@ family of sort functions might be declared like this:
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 A function template can be overloaded with other function templates and
-with normal (non-template) functions. A normal function is not related
-to a function template (i.e., it is never considered to be a
 specialization), even if it has the same name and type as a potentially
 generated function template specialization.[^5]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
@@ -907,15 +936,26 @@ Two expressions involving template parameters are considered
 *equivalent* if two function definitions containing the expressions
 would satisfy the one definition rule ([[basic.def.odr]]), except that
 the tokens used to name the template parameters may differ as long as a
 token used to name a template parameter in one expression is replaced by
 another token that names the same template parameter in the other
-expression.
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 template <int K, int L> void f(A<K+L>);         // same as #1
 ```
 Two expressions involving template parameters that are not equivalent
 are *functionally equivalent* if, for any given set of template
 arguments, the evaluation of the expression results in the same value.
@@ -982,18 +1022,19 @@ specialized template is the one chosen by the partial ordering process.
 To produce the transformed template, for each type, non-type, or
 template template parameter (including template parameter packs (
 [[temp.variadic]]) thereof) synthesize a unique type, value, or class
 template respectively and substitute it for each occurrence of that
 parameter in the function type of the template. If only one of the
-function templates is a non-static member, that function template is
-considered to have a new first parameter inserted in its function
-parameter list. The new parameter is of type “reference to cv `A`,”
-where cv are the cv-qualifiers of the function template (if any) and `A`
-is the class of which the function template is a member. This allows a
-non-static member to be ordered with respect to a nonmember function and
-for the results to be equivalent to the ordering of two equivalent
-nonmembers.
 ``` cpp
 struct A { };
 template<class T> struct B {
   template<class R> int operator*(R&);              // #1

 ```
 However, this syntax is allowed in class template partial
 specializations ([[temp.class.spec]]).
+For purposes of name lookup and instantiation, default arguments and
+*exception-specification*s of function templates and default arguments
+and *exception-specification*s of member functions of class templates
+are considered definitions; each default argument or
+*exception-specification* is a separate definition which is unrelated to
+the function template definition or to any other default arguments or
+*exception-specification*s.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
 v2[3] = dcomplex(7,8);          // Array<dcomplex>::operator[]()
 ```
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
+A member class of a class template may be defined outside the class
+template definition in which it is declared. The member class must be
 defined before its first use that requires an instantiation (
 [[temp.inst]]). For example,
 ``` cpp
 template<class T> struct A {
 A<int>::B  b2;                  // OK: requires A::B to be defined
 ```
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
+A definition for a static data member or static data member template may
+be provided in a namespace scope enclosing the definition of the static
+member’s class template.
 ``` cpp
 template<class T> class X {
   static T s;
 };
 template<class T> T X<T>::s = 0;
+struct limits {
+  template<class T>
+    static const T min;           // declaration
+};
+template<class T>
+  const T limits::min = { };      // definition
 ```
 An explicit specialization of a static data member declared as an array
 of unknown bound can have a different bound from its definition, if any.
 template<class T> template<class T2> int string<T>::compare(const T2& s) {
 }
 ```
+A local class of non-closure type shall not have member templates.
+Access control rules (Clause  [[class.access]]) apply to member template
+names. A destructor shall not be a member template. A non-template
+member function ([[dcl.fct]]) with a given name and type and a member
+function template of the same name, which could be used to generate a
+specialization of the same type, can both be declared in a class. When
+both exist, a use of that name and type refers to the non-template
+member unless an explicit template argument list is supplied.
 ``` cpp
 template <class T> struct A {
   void f(int);
   template <class T2> void f(T2);
 };
+template <> void A<int>::f(int) { }                     // non-template member function
+template <> template <> void A<int>::f<>(int) { }       // member function template specialization
 int main() {
   A<char> ac;
   ac.f(1);          // non-template
   ac.f('c');        // template
     *type-parameter* without the ellipsis.
 - In an *initializer-list* ([[dcl.init]]); the pattern is an
   *initializer-clause*.
 - In a *base-specifier-list* (Clause  [[class.derived]]); the pattern is
   a *base-specifier*.
+- In a *mem-initializer-list* ([[class.base.init]]) for a
+  *mem-initializer* whose *mem-initializer-id* denotes a base class; the
+  pattern is the *mem-initializer*.
 - In a *template-argument-list* ([[temp.arg]]); the pattern is a
   *template-argument*.
 - In a *dynamic-exception-specification* ([[except.spec]]); the pattern
   is a *type-id*.
 - In an *attribute-list* ([[dcl.attr.grammar]]); the pattern is an
 - In a *capture-list* ([[expr.prim.lambda]]); the pattern is a
   *capture*.
 - In a `sizeof...` expression ([[expr.sizeof]]); the pattern is an
   *identifier*.
+For the purpose of determining whether a parameter pack satisfies a rule
+regarding entities other than parameter packs, the parameter pack is
+considered to be the entity that would result from an instantiation of
+the pattern in which it appears.
 ``` cpp
 template<class ... Types> void f(Types ... rest);
 template<class ... Types> void g(Types ... rest) {
   f(&rest ...);     // ``&rest ...'' is a pack expansion; ``&rest'' is its pattern
 }
 The instantiation of a pack expansion that is not a `sizeof...`
 expression produces a list
 $\mathtt{E}_1, \mathtt{E}_2, ..., \mathtt{E}_N$, where N is the number
 of elements in the pack expansion parameters. Each Eᵢ is generated by
 instantiating the pattern and replacing each pack expansion parameter
+with its ith element. Such an element, in the context of the
+instantiation, is interpreted as follows:
+- if the pack is a template parameter pack, the element is a template
+  parameter ([[temp.param]]) of the corresponding kind (type or
+  non-type) designating the type or value from the template argument;
+ otherwise,
+- if the pack is a function parameter pack, the element is an
+  *id-expression* designating the function parameter that resulted from
+  the instantiation of the pattern where the pack is declared.
+All of the Eᵢ become elements in the enclosing list. The variety of list
+varies with the context: *expression-list*, *base-specifier-list*,
+*template-argument-list*, etc. When N is zero, the instantiation of the
+expansion produces an empty list. Such an instantiation does not alter
+the syntactic interpretation of the enclosing construct, even in cases
+where omitting the list entirely would otherwise be ill-formed or would
+result in an ambiguity in the grammar.
 ``` cpp
 template<class... T> struct X : T... { };
 template<class... T> void f(T... values) {
   X<T...> x(values...);
 ### Friends <a id="temp.friend">[[temp.friend]]</a>
 A friend of a class or class template can be a function template or
 class template, a specialization of a function template or class
+template, or a non-template function or class. For a friend function
+declaration that is not a template declaration:
 - if the name of the friend is a qualified or unqualified *template-id*,
   the friend declaration refers to a specialization of a function
+  template, otherwise,
 - if the name of the friend is a *qualified-id* and a matching
   non-template function is found in the specified class or namespace,
   the friend declaration refers to that function, otherwise,
 - if the name of the friend is a *qualified-id* and a matching function
   template is found in the specified class or namespace, the friend
   declaration refers to the deduced specialization of that function
   template ([[temp.deduct.decl]]), otherwise,
+- the name shall be an *unqualified-id* that declares (or redeclares) a
+  non-template function.
 ``` cpp
 template<class T> class task;
 template<class T> task<T>* preempt(task<T>*);
 Here, each specialization of the `task` class template has the function
 `next_time` as a friend; because `process` does not have explicit
 *template-argument*s, each specialization of the `task` class template
 has an appropriately typed function `process` as a friend, and this
 friend is not a function template specialization; because the friend
+`preempt` has an explicit *template-argument* `T`, each specialization
 of the `task` class template has the appropriate specialization of the
 function template `preempt` as a friend; and each specialization of the
 `task` class template has all specializations of the function template
 `func` as friends. Similarly, each specialization of the `task` class
 template has the class template specialization `task<int>` as a friend,
 template<class T> struct A { X::Y ab; };            // OK
 template<class T> struct A<T*> { X::Y ab; };        // OK
 ```
 When a function is defined in a friend function declaration in a class
+template, the function is instantiated when the function is odr-used (
+[[basic.def.odr]]). The same restrictions on multiple declarations and
+definitions that apply to non-template function declarations and
+definitions also apply to these implicit definitions.
 A member of a class template may be declared to be a friend of a
 non-template class. In this case, the corresponding member of every
 specialization of the class template is a friend of the class granting
 friendship. For explicit specializations the corresponding member is the
   int array[5];
   template< int X > class A<X,&array> { };            // error
   ```
 - The argument list of the specialization shall not be identical to the
   implicit argument list of the primary template.
+- The specialization shall be more specialized than the primary
+  template ([[temp.class.order]]).
 - The template parameter list of a specialization shall not contain
   default template argument values.[^4]
 - An argument shall not contain an unexpanded parameter pack. If an
   argument is a pack expansion ([[temp.variadic]]), it shall be the
   last argument in the template argument list.
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 A function template can be overloaded with other function templates and
+with non-template functions ([[dcl.fct]]). A non-template function is
+not related to a function template (i.e., it is never considered to be a
 specialization), even if it has the same name and type as a potentially
 generated function template specialization.[^5]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 *equivalent* if two function definitions containing the expressions
 would satisfy the one definition rule ([[basic.def.odr]]), except that
 the tokens used to name the template parameters may differ as long as a
 token used to name a template parameter in one expression is replaced by
 another token that names the same template parameter in the other
+expression. For determining whether two dependent names ([[temp.dep]])
+are equivalent, only the name itself is considered, not the result of
+name lookup in the context of the template. If multiple declarations of
+the same function template differ in the result of this name lookup, the
+result for the first declaration is used.
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 template <int K, int L> void f(A<K+L>);         // same as #1
+template <class T> decltype(g(T())) h();
+int g(int);
+template <class T> decltype(g(T())) h()         // redeclaration of h() uses the earlier lookup
+  { return g(T()); }                            // ...although the lookup here does find g(int)
+int i = h<int>();                               // template argument substitution fails; g(int)
+                                                // was not in scope at the first declaration of h()
 ```
 Two expressions involving template parameters that are not equivalent
 are *functionally equivalent* if, for any given set of template
 arguments, the evaluation of the expression results in the same value.
 To produce the transformed template, for each type, non-type, or
 template template parameter (including template parameter packs (
 [[temp.variadic]]) thereof) synthesize a unique type, value, or class
 template respectively and substitute it for each occurrence of that
 parameter in the function type of the template. If only one of the
+function templates is a non-static member of some class `A`, that
+function template is considered to have a new first parameter inserted
+in its function parameter list. Given cv as the cv-qualifiers of the
+function template (if any), the new parameter is of type “rvalue
+reference to cv `A`” if the optional *ref-qualifier* of the function
+template is `&&`, or of type “lvalue reference to cv `A`” otherwise.
+This allows a non-static member to be ordered with respect to a
+nonmember function and for the results to be equivalent to the ordering
+of two equivalent nonmembers.
 ``` cpp
 struct A { };
 template<class T> struct B {
   template<class R> int operator*(R&);              // #1

Diff to HTML by rtfpessoa