[temp.class] - C++14 → C++17

Files changed (1) hide show

tmp/tmpex3biw7x/{from.md → to.md} +48 -13

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

@@ -1,13 +1,16 @@
 ### Class templates <a id="temp.class">[[temp.class]]</a>
-A class *template* defines the layout and operations for an unbounded
-set of related types. a single class template `List` might provide a
-common definition for list of `int`, list of `float`, and list of
-pointers to `Shape`s.
-An array class template might be declared like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
@@ -16,14 +19,16 @@ public:
   T& operator[](int);
   T& elem(int i) { return v[i]; }
 };
 ```
-The prefix `template` `<class` `T>` specifies that a template is being
-declared and that a *type-name* `T` will be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 When a member function, a member class, a member enumeration, a static
 data member or a member template of a class template is defined outside
 of the class template definition, the member definition is defined as a
 template definition in which the *template-parameter*s are those of the
 class template. The names of the template parameters used in the
@@ -32,10 +37,12 @@ names used in the class template definition. The template argument list
 following the class template name in the member definition shall name
 the parameters in the same order as the one used in the template
 parameter list of the member. Each template parameter pack shall be
 expanded with an ellipsis in the template argument list.
 ``` cpp
 template<class T1, class T2> struct A {
   void f1();
   void f2();
 };
@@ -52,20 +59,24 @@ template<class ... Types> struct B {
 template<class ... Types> void B<Types ...>::f3() { }    // OK
 template<class ... Types> void B<Types>::f4() { }        // error
 ```
 In a redeclaration, partial specialization, explicit specialization or
 explicit instantiation of a class template, the *class-key* shall agree
 in kind with the original class template declaration (
 [[dcl.type.elab]]).
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
 public:
@@ -83,46 +94,60 @@ template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
 }
 ```
 The *template-argument*s for a member function of a class template are
 determined by the *template-argument*s of the type of the object for
-which the member function is called. the *template-argument* for
-`Array<T> :: operator [] ()` will be determined by the `Array` to which
-the subscripting operation is applied.
 ``` cpp
 Array<int> v1(20);
 Array<dcomplex> v2(30);
 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 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 {
   class B;
 };
 A<int>::B* b1;                  // OK: requires A to be defined but not A::B
 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 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;
@@ -134,30 +159,40 @@ struct limits {
 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.
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];              // 4 elements
 template <> int A<int>::i[] = { 1 };            // OK: 1 element
 ```
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>
 An enumeration member of a class template may be defined outside the
 class template definition.
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
 A<int> a;
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```

 ### Class templates <a id="temp.class">[[temp.class]]</a>
+A *class template* defines the layout and operations for an unbounded
+set of related types.
+[*Example 1*:
+A single class template `List` might provide an unbounded set of class
+definitions: one class `List<T>` for every type `T`, each describing a
+linked list of elements of type `T`. Similarly, a class template `Array`
+describing a contiguous, dynamic array might be defined like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
   T& operator[](int);
   T& elem(int i) { return v[i]; }
 };
 ```
+The prefix `template<class T>` specifies that a template is being
+declared and that a *type-name* `T` may be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
+— *end example*]
 When a member function, a member class, a member enumeration, a static
 data member or a member template of a class template is defined outside
 of the class template definition, the member definition is defined as a
 template definition in which the *template-parameter*s are those of the
 class template. The names of the template parameters used in the
 following the class template name in the member definition shall name
 the parameters in the same order as the one used in the template
 parameter list of the member. Each template parameter pack shall be
 expanded with an ellipsis in the template argument list.
+[*Example 2*:
 ``` cpp
 template<class T1, class T2> struct A {
   void f1();
   void f2();
 };
 template<class ... Types> void B<Types ...>::f3() { }    // OK
 template<class ... Types> void B<Types>::f4() { }        // error
 ```
+— *end example*]
 In a redeclaration, partial specialization, explicit specialization or
 explicit instantiation of a class template, the *class-key* shall agree
 in kind with the original class template declaration (
 [[dcl.type.elab]]).
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
+[*Example 1*:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
 public:
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
 }
 ```
+— *end example*]
 The *template-argument*s for a member function of a class template are
 determined by the *template-argument*s of the type of the object for
+which the member function is called.
+[*Example 2*:
+The *template-argument* for `Array<T>::operator[]()` will be determined
+by the `Array` to which the subscripting operation is applied.
 ``` cpp
 Array<int> v1(20);
 Array<dcomplex> v2(30);
 v1[3] = 7;                      // Array<int>::operator[]()
 v2[3] = dcomplex(7,8);          // Array<dcomplex>::operator[]()
 ```
+— *end example*]
 #### 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.
+[*Note 1*:
+The member class must be defined before its first use that requires an
+instantiation ([[temp.inst]]). For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };
 A<int>::B* b1;                  // OK: requires A to be defined but not A::B
 template<class T> class A<T>::B { };
 A<int>::B  b2;                  // OK: requires A::B to be defined
 ```
+— *end note*]
 #### 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.
+[*Example 1*:
 ``` cpp
 template<class T> class X {
   static T s;
 };
 template<class T> T X<T>::s = 0;
 template<class T>
   const T limits::min = { };    // definition
 ```
+— *end example*]
 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.
+[*Example 2*:
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];              // 4 elements
 template <> int A<int>::i[] = { 1 };            // OK: 1 element
 ```
+— *end example*]
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>
 An enumeration member of a class template may be defined outside the
 class template definition.
+[*Example 1*:
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
 A<int> a;
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```
+— *end example*]

Diff to HTML by rtfpessoa