[class.mem.general] - C++20 → C++23

Files changed (1) hide show

tmp/tmpni47whu9/{from.md → to.md} +357 -0

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

	@@ -0,0 +1,357 @@

+### General <a id="class.mem.general">[[class.mem.general]]</a>
+``` bnf
+member-specification:
+    member-declaration member-specificationₒₚₜ
+    access-specifier ':' member-specificationₒₚₜ
+```
+``` bnf
+member-declaration:
+    attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ member-declarator-listₒₚₜ ';'
+    function-definition
+    using-declaration
+    using-enum-declaration
+    static_assert-declaration
+    template-declaration
+    explicit-specialization
+    deduction-guide
+    alias-declaration
+    opaque-enum-declaration
+    empty-declaration
+```
+``` bnf
+member-declarator-list:
+    member-declarator
+    member-declarator-list ',' member-declarator
+```
+``` bnf
+member-declarator:
+    declarator virt-specifier-seqₒₚₜ pure-specifierₒₚₜ
+    declarator requires-clause
+    declarator brace-or-equal-initializerₒₚₜ
+    identifierₒₚₜ attribute-specifier-seqₒₚₜ ':' constant-expression brace-or-equal-initializerₒₚₜ
+```
+``` bnf
+virt-specifier-seq:
+    virt-specifier
+    virt-specifier-seq virt-specifier
+```
+``` bnf
+virt-specifier:
+    override
+    final
+```
+``` bnf
+pure-specifier:
+    '=' '0'
+```
+The *member-specification* in a class definition declares the full set
+of members of the class; no member can be added elsewhere. A
+*direct member* of a class `X` is a member of `X` that was first
+declared within the *member-specification* of `X`, including anonymous
+union members [[class.union.anon]] and direct members thereof. Members
+of a class are data members, member functions [[class.mfct]], nested
+types, enumerators, and member templates [[temp.mem]] and
+specializations thereof.
+[*Note 1*: A specialization of a static data member template is a
+static data member. A specialization of a member function template is a
+member function. A specialization of a member class template is a nested
+class. — *end note*]
+A *member-declaration* does not declare new members of the class if it
+is
+- a friend declaration [[class.friend]],
+- a *deduction-guide* [[temp.deduct.guide]],
+- a *template-declaration* whose *declaration* is one of the above,
+- a *static_assert-declaration*,
+- a *using-declaration* [[namespace.udecl]], or
+- an *empty-declaration*.
+For any other *member-declaration*, each declared entity that is not an
+unnamed bit-field [[class.bit]] is a member of the class, and each such
+*member-declaration* shall either declare at least one member name of
+the class or declare at least one unnamed bit-field.
+A *data member* is a non-function member introduced by a
+*member-declarator*. A *member function* is a member that is a function.
+Nested types are classes [[class.name]], [[class.nest]] and enumerations
+[[dcl.enum]] declared in the class and arbitrary types declared as
+members by use of a typedef declaration [[dcl.typedef]] or
+*alias-declaration*. The enumerators of an unscoped enumeration
+[[dcl.enum]] defined in the class are members of the class.
+A data member or member function may be declared `static` in its
+*member-declaration*, in which case it is a *static member* (see
+[[class.static]]) (a *static data member* [[class.static.data]] or
+*static member function* [[class.static.mfct]], respectively) of the
+class. Any other data member or member function is a *non-static member*
+(a *non-static data member* or *non-static member function*
+[[class.mfct.non.static]], respectively).
+[*Note 2*: A non-static data member of non-reference type is a member
+subobject of a class object [[intro.object]]. — *end note*]
+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
+- an enumeration can be introduced with an *opaque-enum-declaration* and
+  later redeclared with an *enum-specifier*.
+[*Note 3*: A single name can denote several member functions provided
+their types are sufficiently different
+[[basic.scope.scope]]. — *end note*]
+A redeclaration of a class member outside its class definition shall be
+a definition, an explicit specialization, or an explicit instantiation
+[[temp.expl.spec]], [[temp.explicit]]. The member shall not be a
+non-static data member.
+A *complete-class context* of a class (template) is a
+- function body [[dcl.fct.def.general]],
+- default argument [[dcl.fct.default]],
+- default template argument [[temp.param]],
+- *noexcept-specifier* [[except.spec]], or
+- default member initializer
+within the *member-specification* of the class or class template.
+[*Note 4*: A complete-class context of a nested class is also a
+complete-class context of any enclosing class, if the nested class is
+defined within the *member-specification* of the enclosing
+class. — *end note*]
+A class is regarded as complete where its definition is reachable and
+within its complete-class contexts; otherwise it is regarded as
+incomplete within its own class *member-specification*.
+In a *member-declarator*, an `=` immediately following the *declarator*
+is interpreted as introducing a *pure-specifier* if the *declarator-id*
+has function type, otherwise it is interpreted as introducing a
+*brace-or-equal-initializer*.
+[*Example 1*:
+``` cpp
+struct S {
+  using T = void();
+  T * p = 0;        // OK, brace-or-equal-initializer
+  virtual T f = 0;  // OK, pure-specifier
+};
+```
+— *end example*]
+In a *member-declarator* for a bit-field, the *constant-expression* is
+parsed as the longest sequence of tokens that could syntactically form a
+*constant-expression*.
+[*Example 2*:
+``` cpp
+int a;
+const int b = 0;
+struct S {
+  int x1 : 8 = 42;              // OK, "= 42" is brace-or-equal-initializer
+  int x2 : 8 { 42 };            // OK, "{ 42 \"} is brace-or-equal-initializer
+  int y1 : true ? 8 : a = 42;   // OK, brace-or-equal-initializer is absent
+  int y2 : true ? 8 : b = 42;   // error: cannot assign to const int
+  int y3 : (true ? 8 : b) = 42; // OK, "= 42" is brace-or-equal-initializer
+  int z : 1 || new int { 0 };   // OK, brace-or-equal-initializer is absent
+};
+```
+— *end example*]
+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]] and
+[[dcl.init.aggr]]). A *brace-or-equal-initializer* for a non-static data
+member specifies a *default member initializer* for the member, and
+shall not directly or indirectly cause the implicit definition of a
+defaulted default constructor for the enclosing class or the exception
+specification of that constructor. An immediate invocation
+[[expr.const]] that is a potentially-evaluated subexpression
+[[intro.execution]] of a default member initializer is neither evaluated
+nor checked for whether it is a constant expression at the point where
+the subexpression appears.
+A member shall not be declared with the `extern`
+*storage-class-specifier*. Within a class definition, a member shall not
+be declared with the `thread_local` *storage-class-specifier* unless
+also declared `static`.
+The *decl-specifier-seq* may be omitted in constructor, destructor, and
+conversion function declarations only; when declaring another kind of
+member the *decl-specifier-seq* shall contain a *type-specifier* that is
+not a *cv-qualifier*. The *member-declarator-list* can be omitted only
+after a *class-specifier* or an *enum-specifier* or in a friend
+declaration [[class.friend]]. A *pure-specifier* shall be used only in
+the declaration of a virtual function [[class.virtual]] that is not a
+friend declaration.
+The optional *attribute-specifier-seq* in a *member-declaration*
+appertains to each of the entities declared by the *member-declarator*s;
+it shall not appear if the optional *member-declarator-list* is omitted.
+A *virt-specifier-seq* shall contain at most one of each
+*virt-specifier*. A *virt-specifier-seq* shall appear only in the first
+declaration of a virtual member function [[class.virtual]].
+The type of a non-static data member shall not be an incomplete type
+[[term.incomplete.type]], an abstract class type [[class.abstract]], or
+a (possibly multidimensional) array thereof.
+[*Note 5*: In particular, a class `C` cannot contain a non-static
+member of class `C`, but it can contain a pointer or reference to an
+object of class `C`. — *end note*]
+[*Note 6*: See  [[expr.prim.id]] for restrictions on the use of
+non-static data members and non-static member functions. — *end note*]
+[*Note 7*: The type of a non-static member function is an ordinary
+function type, and the type of a non-static data member is an ordinary
+object type. There are no special member function types or data member
+types. — *end note*]
+[*Example 3*:
+A simple example of a class definition is
+``` cpp
+struct tnode {
+  char tword[20];
+  int count;
+  tnode* left;
+  tnode* right;
+};
+```
+which contains an array of twenty characters, an integer, and two
+pointers to objects of the same type. Once this definition has been
+given, the declaration
+``` cpp
+tnode s, *sp;
+```
+declares `s` to be a `tnode` and `sp` to be a pointer to a `tnode`. With
+these declarations, `sp->count` refers to the `count` member of the
+object to which `sp` points; `s.left` refers to the `left` subtree
+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`.
+— *end example*]
+[*Note 8*:  Non-variant non-static data members of non-zero size
+[[intro.object]] are allocated so that later members have higher
+addresses within a class object [[expr.rel]]. Implementation alignment
+requirements can cause two adjacent members not to be allocated
+immediately after each other; so can requirements for space for managing
+virtual functions [[class.virtual]] and virtual base classes
+[[class.mi]]. — *end note*]
+If `T` is the name of a class, then each of the following shall have a
+name different from `T`:
+- every static data member of class `T`;
+- every member function of class `T`; \[*Note 9*: This restriction does
+  not apply to constructors, which do not have names
+  [[class.ctor]] — *end note*]
+- every member of class `T` that is itself a type;
+- every member template of class `T`;
+- every enumerator of every member of class `T` that is an unscoped
+  enumeration type; and
+- every member of every anonymous union that is a member of class `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`.
+The *common initial sequence* of two standard-layout struct
+[[class.prop]] types is the longest sequence of non-static data members
+and bit-fields in declaration order, starting with the first such entity
+in each of the structs, such that
+- corresponding entities have layout-compatible types [[basic.types]],
+- corresponding entities have the same alignment requirements
+  [[basic.align]],
+- either both entities are declared with the `no_unique_address`
+  attribute [[dcl.attr.nouniqueaddr]] or neither is, and
+- either both entities are bit-fields with the same width or neither is
+  a bit-field.
+[*Example 4*:
+``` cpp
+struct A { int a; char b; };
+struct B { const int b1; volatile char b2; };
+struct C { int c; unsigned : 0; char b; };
+struct D { int d; char b : 4; };
+struct E { unsigned int e; char b; };
+```
+The common initial sequence of `A` and `B` comprises all members of
+either class. The common initial sequence of `A` and `C` and of `A` and
+`D` comprises the first member in each case. The common initial sequence
+of `A` and `E` is empty.
+— *end example*]
+Two standard-layout struct [[class.prop]] types are *layout-compatible
+classes* if their common initial sequence comprises all members and
+bit-fields of both classes [[basic.types]].
+Two standard-layout unions 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
+[[term.layout.compatible.type]].
+In a standard-layout union with an active member [[class.union]] of
+struct type `T1`, it is permitted to read a non-static data member `m`
+of another union member of struct type `T2` provided `m` is part of the
+common initial sequence of `T1` and `T2`; the behavior is as if the
+corresponding member of `T1` were nominated.
+[*Example 5*:
+``` cpp
+struct T1 { int a, b; };
+struct T2 { int c; double d; };
+union U { T1 t1; T2 t2; };
+int f() {
+  U u = { { 1, 2 } };   // active member is t1
+  return u.t2.c;        // OK, as if u.t1.a were nominated
+}
+```
+— *end example*]
+[*Note 10*: Reading a volatile object through a glvalue of non-volatile
+type has undefined behavior [[dcl.type.cv]]. — *end note*]
+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
+if that member is not a bit-field. Its address is also the same as the
+address of each of its base class subobjects.
+[*Note 11*: There can therefore be unnamed padding within a
+standard-layout struct object inserted by an implementation, but not at
+its beginning, as necessary to achieve appropriate
+alignment. — *end note*]
+[*Note 12*: The object and its first subobject are
+pointer-interconvertible
+[[basic.compound]], [[expr.static.cast]]. — *end note*]

Diff to HTML by rtfpessoa