[class] - C++11 → C++14

Files changed (1) hide show

tmp/tmpgxtvb7h4/{from.md → to.md} +107 -85

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

@@ -56,22 +56,36 @@ defined. The optional *attribute-specifier-seq* appertains to the class;
 the attributes in the *attribute-specifier-seq* are thereafter
 considered attributes of the class whenever it is named.
 If a class is marked with the *class-virt-specifier* `final` and it
 appears as a *base-type-specifier* in a *base-clause* (Clause
-[[class.derived]]), the program is ill-formed.
 Complete objects and member subobjects of class type shall have nonzero
 size.[^1] Class objects can be assigned, passed as arguments to
 functions, and returned by functions (except objects of classes for
 which copying or moving has been restricted; see  [[class.copy]]). Other
 plausible operators, such as equality comparison, can be defined by the
 user; see  [[over.oper]].
-A *union* is a class defined with the *class-key* `union`; it holds only
-one data member at a time ([[class.union]]). Aggregates of class type
-are described in  [[dcl.init.aggr]].
 A *trivially copyable class* is a class that:
 - has no non-trivial copy constructors ([[class.copy]]),
 - has no non-trivial move constructors ([[class.copy]]),
@@ -79,15 +93,14 @@ A *trivially copyable class* is a class that:
   [[class.copy]]),
 - has no non-trivial move assignment operators ([[over.ass]],
   [[class.copy]]), and
 - has a trivial destructor ([[class.dtor]]).
-A *trivial class* is a class that has a trivial default constructor (
-[[class.ctor]]) and is trivially copyable.
-In particular, a trivially copyable or trivial class does not have
-virtual functions or virtual base classes.
 A *standard-layout class* is a class that:
 - has no non-static data members of type non-standard-layout class (or
   array of such types) or reference,
@@ -112,14 +125,14 @@ in other programming languages. Their layout is specified in
 [[class.mem]].
 A *POD struct*[^3] is a non-union class that is both a trivial class and
 a standard-layout class, and has no non-static data members of type
 non-POD struct, non-POD union (or array of such types). Similarly, a
-*POD union* is a union that is both a trivial class and a standard
-layout class, and has no non-static data members of type non-POD struct,
-non-POD union (or array of such types). A *POD class* is a class that is
-either a POD struct or a POD union.
 ``` cpp
 struct N {          // neither trivial nor standard-layout
   int i;
   int j;
@@ -293,15 +306,16 @@ member-specification:
 ```
 ``` bnf
 member-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ member-declarator-listₒₚₜ ';'
-    function-definition ';'ₒₚₜ
     using-declaration
     static_assert-declaration
     template-declaration
     alias-declaration
 ```
 ``` bnf
 member-declarator-list:
     member-declarator
@@ -339,39 +353,37 @@ types, and enumerators. Data members and member functions are static or
 non-static; see  [[class.static]]. Nested types are classes (
 [[class.name]],  [[class.nest]]) and enumerations ([[dcl.enum]])
 defined in the class, and arbitrary types declared as members by use of
 a typedef declaration ([[dcl.typedef]]). The enumerators of an unscoped
 enumeration ([[dcl.enum]]) defined in the class are members of the
-class. Except when used to declare friends ([[class.friend]]) or to
-introduce the name of a member of a base class into a derived class (
-[[namespace.udecl]]), *member-declaration*s declare members of the
-class, and each such *member-declaration* shall declare at least one
-member name of the class. A member shall not be declared twice in the
-*member-specification*, except that a nested class or member class
-template can be declared and then later defined, and except that an
-enumeration can be introduced with an *opaque-enum-declaration* and
-later redeclared with an *enum-specifier*.
 A class is considered a completely-defined object type (
 [[basic.types]]) (or complete type) at the closing `}` of the
 *class-specifier*. Within the class *member-specification*, the class is
 regarded as complete within function bodies, default arguments,
-*exception-specification*s, and *brace-or-equal-initializer*s for
-non-static data members (including such things in nested classes).
-Otherwise it is regarded as incomplete within its own class
-*member-specification*.
 A single name can denote several function members provided their types
 are sufficiently different (Clause  [[over]]).
-A member can be initialized using a constructor; see  [[class.ctor]].
-See Clause  [[special]] for a description of constructors and other
-special member functions.
-A member can be initialized using a *brace-or-equal-initializer*. (For
-static data members, see  [[class.static.data]]; for non-static data
-members, see  [[class.base.init]]).
 A member shall not be declared with the `extern` or `register` . Within
 a class definition, a member shall not be declared with the
 `thread_local` unless also declared `static`.
@@ -429,14 +441,14 @@ pointer of the object `s`; and `s.right->tword[0]` refers to the initial
 character of the `tword` member of the `right` subtree of `s`.
 Nonstatic data members of a (non-union) class with the same access
 control (Clause  [[class.access]]) are allocated so that later members
 have higher addresses within a class object. The order of allocation of
-non-static data members with different access control is unspecified (
-[[class.access]]). Implementation alignment requirements might cause two
-adjacent members not to be allocated immediately after each other; so
-might requirements for space for managing virtual functions (
 [[class.virtual]]) and virtual base classes ([[class.mi]]).
 If `T` is the name of a class, then each of the following shall have a
 name different from `T`:
@@ -451,16 +463,16 @@ name different from `T`:
 In addition, if class `T` has a user-declared constructor (
 [[class.ctor]]), every non-static data member of class `T` shall have a
 name different from `T`.
 Two standard-layout struct (Clause  [[class]]) types are
-layout-compatible if they have the same number of non-static data
 members and corresponding non-static data members (in declaration order)
 have layout-compatible types ([[basic.types]]).
 Two standard-layout union (Clause  [[class]]) types are
-layout-compatible if they have the same number of non-static data
 members and corresponding non-static data members (in any order) have
 layout-compatible types ([[basic.types]]).
 If a standard-layout union contains two or more standard-layout structs
 that share a common initial sequence, and if the standard-layout union
@@ -469,16 +481,16 @@ permitted to inspect the common initial part of any of them. Two
 standard-layout structs share a common initial sequence if corresponding
 members have layout-compatible types and either neither member is a
 bit-field or both are bit-fields with the same width for a sequence of
 one or more initial members.
-A pointer to a standard-layout struct object, suitably converted using a
-`reinterpret_cast`, points to its initial member (or if that member is a
-bit-field, then to the unit in which it resides) and vice versa. There
-might therefore be unnamed padding within a standard-layout struct
-object, but not at its beginning, as necessary to achieve appropriate
-alignment.
 ## Member functions <a id="class.mfct">[[class.mfct]]</a>
 Functions declared in the definition of a class, excluding those
 declared with a `friend` specifier ([[class.friend]]), are called
@@ -657,16 +669,13 @@ keyword `this` is a prvalue expression whose value is the address of the
 object for which the function is called. The type of `this` in a member
 function of a class `X` is `X*`. If the member function is declared
 `const`, the type of `this` is `const` `X*`, if the member function is
 declared `volatile`, the type of `this` is `volatile` `X*`, and if the
 member function is declared `const` `volatile`, the type of `this` is
-`const` `volatile` `X*`.
-In a `const` member function, the object for which the function is
-called is accessed through a `const` access path; therefore, a `const`
-member function shall not modify the object and its non-static data
-members.
 ``` cpp
 struct s {
   int a;
   int f() const;
@@ -854,24 +863,24 @@ contains several standard-layout structs that share a common initial
 sequence ([[class.mem]]), and if an object of this standard-layout
 union type contains one of the standard-layout structs, it is permitted
 to inspect the common initial sequence of any of standard-layout struct
 members; see  [[class.mem]]. The size of a union is sufficient to
 contain the largest of its non-static data members. Each non-static data
-member is allocated as if it were the sole member of a struct.
 A union can have member functions (including constructors and
 destructors), but not virtual ([[class.virtual]]) functions. A union
 shall not have base classes. A union shall not be used as a base class.
 If a union contains a non-static data member of reference type the
-program is ill-formed. At most one non-static data member of a union may
-have a *brace-or-equal-initializer*. If any non-static data member of a
-union has a non-trivial default constructor ([[class.ctor]]), copy
-constructor ([[class.copy]]), move constructor ([[class.copy]]), copy
-assignment operator ([[class.copy]]), move assignment operator (
-[[class.copy]]), or destructor ([[class.dtor]]), the corresponding
-member function of the union must be user-provided or it will be
-implicitly deleted ([[dcl.fct.def.delete]]) for the union.
 Consider the following union:
 ``` cpp
 union U {
@@ -900,19 +909,19 @@ u.m.~M();
 new (&u.n) N;
 ```
 A union of the form
-is called an anonymous union; it defines an unnamed object of unnamed
 type. The *member-specification* of an anonymous union shall only define
-non-static data members. Nested types and functions cannot be declared
-within an anonymous union. The names of the members of an anonymous
-union shall be distinct from the names of any other entity in the scope
-in which the anonymous union is declared. For the purpose of name
-lookup, after the anonymous union definition, the members of the
-anonymous union are considered to have been defined in the scope in
-which the anonymous union is declared.
 ``` cpp
 void f() {
   union { int a; const char* p; };
   a = 1;
@@ -929,29 +938,44 @@ scope shall be declared with any storage class allowed for a block-scope
 variable, or with no storage class. A storage class is not allowed in a
 declaration of an anonymous union in a class scope. An anonymous union
 shall not have `private` or `protected` members (Clause
 [[class.access]]). An anonymous union shall not have function members.
-A union for which objects or pointers are declared is not an anonymous
-union.
 ``` cpp
   union { int aa; char* p; } obj, *ptr = &obj;
   aa = 1;                         // error
   ptr->aa = 1;                    // OK
 ```
 The assignment to plain `aa` is ill-formed since the member name is not
 visible outside the union, and even if it were visible, it is not
 associated with any particular object. Initialization of unions with no
 user-declared constructors is described in ([[dcl.init.aggr]]).
 A *union-like class* is a union or a class that has an anonymous union
 as a direct member. A union-like class `X` has a set of *variant
-members*. If `X` is a union its variant members are the non-static data
-members; otherwise, its variant members are the non-static data members
-of all anonymous unions that are members of `X`.
 ## Bit-fields <a id="class.bit">[[class.bit]]</a>
 A *member-declarator* of the form
@@ -978,21 +1002,19 @@ externally-imposed layouts. As a special case, an unnamed bit-field with
 a width of zero specifies alignment of the next bit-field at an
 allocation unit boundary. Only when declaring an unnamed bit-field may
 the value of the *constant-expression* be equal to zero.
 A bit-field shall not be a static member. A bit-field shall have
-integral or enumeration type ([[basic.fundamental]]). It is
-*implementation-defined* whether a plain (neither explicitly signed nor
-unsigned) `char`, `short`, `int`, `long`, or `long long` bit-field is
-signed or unsigned. A `bool` value can successfully be stored in a
-bit-field of any nonzero size. The address-of operator `&` shall not be
-applied to a bit-field, so there are no pointers to bit-fields. A
-non-const reference shall not be bound to a bit-field (
-[[dcl.init.ref]]). If the initializer for a reference of type `const`
-`T&` is an lvalue that refers to a bit-field, the reference is bound to
-a temporary initialized to hold the value of the bit-field; the
-reference is not bound to the bit-field directly. See  [[dcl.init.ref]].
 If the value `true` or `false` is stored into a bit-field of type `bool`
 of any size (including a one bit bit-field), the original `bool` value
 and the value of the bit-field shall compare equal. If the value of an
 enumerator is stored into a bit-field of the same enumeration type and

 the attributes in the *attribute-specifier-seq* are thereafter
 considered attributes of the class whenever it is named.
 If a class is marked with the *class-virt-specifier* `final` and it
 appears as a *base-type-specifier* in a *base-clause* (Clause
+[[class.derived]]), the program is ill-formed. Whenever a *class-key* is
+followed by a *class-head-name*, the *identifier* `final`, and a colon
+or left brace, `final` is interpreted as a *class-virt-specifier*.
+``` cpp
+struct A;
+struct A final {};      // OK: definition of struct A,
+                        // not value-initialization of variable final
+struct X {
+ struct C { constexpr operator int() { return 5; } };
+ struct B final : C{};  // OK: definition of nested class B,
+                        // not declaration of a bit-field member final
+};
+```
 Complete objects and member subobjects of class type shall have nonzero
 size.[^1] Class objects can be assigned, passed as arguments to
 functions, and returned by functions (except objects of classes for
 which copying or moving has been restricted; see  [[class.copy]]). Other
 plausible operators, such as equality comparison, can be defined by the
 user; see  [[over.oper]].
+A *union* is a class defined with the *class-key* `union`; it holds at
+most one data member at a time ([[class.union]]). Aggregates of class
+type are described in  [[dcl.init.aggr]].
 A *trivially copyable class* is a class that:
 - has no non-trivial copy constructors ([[class.copy]]),
 - has no non-trivial move constructors ([[class.copy]]),
   [[class.copy]]),
 - has no non-trivial move assignment operators ([[over.ass]],
   [[class.copy]]), and
 - has a trivial destructor ([[class.dtor]]).
+A *trivial class* is a class that has a default constructor (
+[[class.ctor]]), has no non-trivial default constructors, and is
+trivially copyable. In particular, a trivially copyable or trivial class
+does not have virtual functions or virtual base classes.
 A *standard-layout class* is a class that:
 - has no non-static data members of type non-standard-layout class (or
   array of such types) or reference,
 [[class.mem]].
 A *POD struct*[^3] is a non-union class that is both a trivial class and
 a standard-layout class, and has no non-static data members of type
 non-POD struct, non-POD union (or array of such types). Similarly, a
+*POD union* is a union that is both a trivial class and a
+standard-layout class, and has no non-static data members of type
+non-POD struct, non-POD union (or array of such types). A *POD class* is
+a class that is either a POD struct or a POD union.
 ``` cpp
 struct N {          // neither trivial nor standard-layout
   int i;
   int j;
 ```
 ``` bnf
 member-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ member-declarator-listₒₚₜ ';'
+    function-definition
     using-declaration
     static_assert-declaration
     template-declaration
     alias-declaration
+    empty-declaration
 ```
 ``` bnf
 member-declarator-list:
     member-declarator
 non-static; see  [[class.static]]. Nested types are classes (
 [[class.name]],  [[class.nest]]) and enumerations ([[dcl.enum]])
 defined in the class, and arbitrary types declared as members by use of
 a typedef declaration ([[dcl.typedef]]). The enumerators of an unscoped
 enumeration ([[dcl.enum]]) defined in the class are members of the
+class. Except when used to declare friends ([[class.friend]]), to
+declare an unnamed bit-field ([[class.bit]]), or to introduce the name
+of a member of a base class into a derived class ([[namespace.udecl]]),
+or when the declaration is an *empty-declaration*, *member-declaration*s
+declare members of the class, and each such *member-declaration* shall
+declare at least one member name of the class. A member shall not be
+declared twice in the *member-specification*, except that a nested class
+or member class template can be declared and then later defined, and
+except that an enumeration can be introduced with an
+*opaque-enum-declaration* and later redeclared with an *enum-specifier*.
 A class is considered a completely-defined object type (
 [[basic.types]]) (or complete type) at the closing `}` of the
 *class-specifier*. Within the class *member-specification*, the class is
 regarded as complete within function bodies, default arguments,
+*using-declaration*s introducing inheriting constructors (
+[[class.inhctor]]), *exception-specification*s, and
+*brace-or-equal-initializer*s for non-static data members (including
+such things in nested classes). Otherwise it is regarded as incomplete
+within its own class *member-specification*.
 A single name can denote several function members provided their types
 are sufficiently different (Clause  [[over]]).
+A *brace-or-equal-initializer* shall appear only in the declaration of a
+data member. (For static data members, see  [[class.static.data]]; for
+non-static data members, see  [[class.base.init]]).
 A member shall not be declared with the `extern` or `register` . Within
 a class definition, a member shall not be declared with the
 `thread_local` unless also declared `static`.
 character of the `tword` member of the `right` subtree of `s`.
 Nonstatic data members of a (non-union) class with the same access
 control (Clause  [[class.access]]) are allocated so that later members
 have higher addresses within a class object. The order of allocation of
+non-static data members with different access control is unspecified
+(Clause  [[class.access]]). Implementation alignment requirements might
+cause two adjacent members not to be allocated immediately after each
+other; so might requirements for space for managing virtual functions (
 [[class.virtual]]) and virtual base classes ([[class.mi]]).
 If `T` is the name of a class, then each of the following shall have a
 name different from `T`:
 In addition, if class `T` has a user-declared constructor (
 [[class.ctor]]), every non-static data member of class `T` shall have a
 name different from `T`.
 Two standard-layout struct (Clause  [[class]]) types are
+*layout-compatible* if they have the same number of non-static data
 members and corresponding non-static data members (in declaration order)
 have layout-compatible types ([[basic.types]]).
 Two standard-layout union (Clause  [[class]]) types are
+*layout-compatible* if they have the same number of non-static data
 members and corresponding non-static data members (in any order) have
 layout-compatible types ([[basic.types]]).
 If a standard-layout union contains two or more standard-layout structs
 that share a common initial sequence, and if the standard-layout union
 standard-layout structs share a common initial sequence if corresponding
 members have layout-compatible types and either neither member is a
 bit-field or both are bit-fields with the same width for a sequence of
 one or more initial members.
+If a standard-layout class object has any non-static data members, its
+address is the same as the address of its first non-static data member.
+Otherwise, its address is the same as the address of its first base
+class subobject (if any). There might therefore be unnamed padding
+within a standard-layout struct object, but not at its beginning, as
+necessary to achieve appropriate alignment.
 ## Member functions <a id="class.mfct">[[class.mfct]]</a>
 Functions declared in the definition of a class, excluding those
 declared with a `friend` specifier ([[class.friend]]), are called
 object for which the function is called. The type of `this` in a member
 function of a class `X` is `X*`. If the member function is declared
 `const`, the type of `this` is `const` `X*`, if the member function is
 declared `volatile`, the type of `this` is `volatile` `X*`, and if the
 member function is declared `const` `volatile`, the type of `this` is
+`const` `volatile` `X*`. thus in a `const` member function, the object
+for which the function is called is accessed through a `const` access
+path.
 ``` cpp
 struct s {
   int a;
   int f() const;
 sequence ([[class.mem]]), and if an object of this standard-layout
 union type contains one of the standard-layout structs, it is permitted
 to inspect the common initial sequence of any of standard-layout struct
 members; see  [[class.mem]]. The size of a union is sufficient to
 contain the largest of its non-static data members. Each non-static data
+member is allocated as if it were the sole member of a struct. All
+non-static data members of a union object have the same address.
 A union can have member functions (including constructors and
 destructors), but not virtual ([[class.virtual]]) functions. A union
 shall not have base classes. A union shall not be used as a base class.
 If a union contains a non-static data member of reference type the
+program is ill-formed. If any non-static data member of a union has a
+non-trivial default constructor ([[class.ctor]]), copy constructor (
+[[class.copy]]), move constructor ([[class.copy]]), copy assignment
+operator ([[class.copy]]), move assignment operator ([[class.copy]]),
+or destructor ([[class.dtor]]), the corresponding member function of
+the union must be user-provided or it will be implicitly deleted (
+[[dcl.fct.def.delete]]) for the union.
 Consider the following union:
 ``` cpp
 union U {
 new (&u.n) N;
 ```
 A union of the form
+is called an *anonymous union*; it defines an unnamed object of unnamed
 type. The *member-specification* of an anonymous union shall only define
+non-static data members. Nested types, anonymous unions, and functions
+cannot be declared within an anonymous union. The names of the members
+of an anonymous union shall be distinct from the names of any other
+entity in the scope in which the anonymous union is declared. For the
+purpose of name lookup, after the anonymous union definition, the
+members of the anonymous union are considered to have been defined in
+the scope in which the anonymous union is declared.
 ``` cpp
 void f() {
   union { int a; const char* p; };
   a = 1;
 variable, or with no storage class. A storage class is not allowed in a
 declaration of an anonymous union in a class scope. An anonymous union
 shall not have `private` or `protected` members (Clause
 [[class.access]]). An anonymous union shall not have function members.
+A union for which objects, pointers, or references are declared is not
+an anonymous union.
 ``` cpp
+void f() {
   union { int aa; char* p; } obj, *ptr = &obj;
   aa = 1;                         // error
   ptr->aa = 1;                    // OK
+}
 ```
 The assignment to plain `aa` is ill-formed since the member name is not
 visible outside the union, and even if it were visible, it is not
 associated with any particular object. Initialization of unions with no
 user-declared constructors is described in ([[dcl.init.aggr]]).
 A *union-like class* is a union or a class that has an anonymous union
 as a direct member. A union-like class `X` has a set of *variant
+members*. If `X` is a union, a non-static data member of `X` that is not
+an anonymous union is a variant member of `X`. In addition, a non-static
+data member of an anonymous union that is a member of `X` is also a
+variant member of `X`. At most one variant member of a union may have a
+*brace-or-equal-initializer*.
+``` cpp
+union U {
+  int x = 0;
+  union { };
+  union {
+    int z;
+    int y = 1; // error: initialization for second variant member of U
+  };
+};
+```
 ## Bit-fields <a id="class.bit">[[class.bit]]</a>
 A *member-declarator* of the form
 a width of zero specifies alignment of the next bit-field at an
 allocation unit boundary. Only when declaring an unnamed bit-field may
 the value of the *constant-expression* be equal to zero.
 A bit-field shall not be a static member. A bit-field shall have
+integral or enumeration type ([[basic.fundamental]]). A `bool` value
+can successfully be stored in a bit-field of any nonzero size. The
+address-of operator `&` shall not be applied to a bit-field, so there
+are no pointers to bit-fields. A non-const reference shall not be bound
+to a bit-field ([[dcl.init.ref]]). If the initializer for a reference
+of type `const` `T&` is an lvalue that refers to a bit-field, the
+reference is bound to a temporary initialized to hold the value of the
+bit-field; the reference is not bound to the bit-field directly. See
+[[dcl.init.ref]].
 If the value `true` or `false` is stored into a bit-field of type `bool`
 of any size (including a one bit bit-field), the original `bool` value
 and the value of the bit-field shall compare equal. If the value of an
 enumerator is stored into a bit-field of the same enumeration type and

Diff to HTML by rtfpessoa