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

Files changed (1) hide show

tmp/tmpj4_anx9y/{from.md → to.md} +764 -61

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

@@ -11,10 +11,11 @@ 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
@@ -46,77 +47,136 @@ virt-specifier:
 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. Members of a
-class are data members, member functions ([[class.mfct]]), nested
-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]]), 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`.
 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]]).
 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
 declaration of a virtual member function ([[class.virtual]]).
-Non-`static` ([[class.static]]) data members shall not have incomplete
-types. In particular, a class `C` shall not contain a non-static member
-of class `C`, but it can contain a pointer or reference to an object of
-class `C`.
-See  [[expr.prim]] for restrictions on the use of non-static data
-members and non-static member functions.
-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.
 A simple example of a class definition is
 ``` cpp
 struct tnode {
@@ -139,11 +199,13 @@ 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`.
-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
@@ -152,42 +214,683 @@ other; so might requirements for space for managing virtual functions (
 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` This restriction does not apply to
-  constructors, which do not have names ([[class.ctor]]) ;
 - every member of class `T` that is itself a type;
 - every enumerator of every member of class `T` that is an unscoped
   enumerated 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`.
 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
-object currently contains one of these standard-layout structs, it is
-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.
 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.

     attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ member-declarator-listₒₚₜ ';'
     function-definition
     using-declaration
     static_assert-declaration
     template-declaration
+    deduction-guide
     alias-declaration
     empty-declaration
 ```
 ``` 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 objects (
+[[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 *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 (Clause
+[[over]]). — *end note*]
 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,
+*noexcept-specifier*s, and default member initializers (including such
+things in nested classes). 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*]
 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.
+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
 declaration of a virtual member function ([[class.virtual]]).
+Non-static data members shall not have incomplete types. In particular,
+a class `C` shall not contain a non-static member of class `C`, but it
+can contain a pointer or reference to an object of class `C`.
+[*Note 4*: See  [[expr.prim]] for restrictions on the use of non-static
+data members and non-static member functions. — *end note*]
+[*Note 5*: 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 2*:
 A simple example of a class definition is
 ``` cpp
 struct tnode {
 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*]
+Non-static 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
 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 6*: 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
   enumerated 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 (Clause
+[[class]]) 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 and either neither entity is a bit-field or both
+are bit-fields with the same width.
+[*Example 3*:
+``` 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 (Clause  [[class]]) 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 ([[basic.types]]).
+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 4*:
+``` 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 7*: Reading a volatile object through a non-volatile glvalue 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.
 Otherwise, its address is the same as the address of its first base
+class subobject (if any).
+[*Note 8*: There might therefore be unnamed padding within a
+standard-layout struct object, but not at its beginning, as necessary to
+achieve appropriate alignment. — *end note*]
+[*Note 9*: The object and its first subobject are
+pointer-interconvertible ([[basic.compound]],
+[[expr.static.cast]]). — *end note*]
+### Member functions <a id="class.mfct">[[class.mfct]]</a>
+A member function may be defined ([[dcl.fct.def]]) in its class
+definition, in which case it is an *inline* member function (
+[[dcl.inline]]), or it may be defined outside of its class definition if
+it has already been declared but not defined in its class definition. A
+member function definition that appears outside of the class definition
+shall appear in a namespace scope enclosing the class definition. Except
+for member function definitions that appear outside of a class
+definition, and except for explicit specializations of member functions
+of class templates and member function templates ([[temp.spec]])
+appearing outside of the class definition, a member function shall not
+be redeclared.
+An inline member function (whether static or non-static) may also be
+defined outside of its class definition provided either its declaration
+in the class definition or its definition outside of the class
+definition declares the function as `inline` or `constexpr`.
+[*Note 1*: Member functions of a class in namespace scope have the
+linkage of that class. Member functions of a local class (
+[[class.local]]) have no linkage. See  [[basic.link]]. — *end note*]
+[*Note 2*: There can be at most one definition of a non-inline member
+function in a program. There may be more than one `inline` member
+function definition in a program. See  [[basic.def.odr]] and
+[[dcl.inline]]. — *end note*]
+If the definition of a member function is lexically outside its class
+definition, the member function name shall be qualified by its class
+name using the `::` operator.
+[*Note 3*: A name used in a member function definition (that is, in the
+*parameter-declaration-clause* including the default arguments (
+[[dcl.fct.default]]) or in the member function body) is looked up as
+described in  [[basic.lookup]]. — *end note*]
+[*Example 1*:
+``` cpp
+struct X {
+  typedef int T;
+  static T count;
+  void f(T);
+};
+void X::f(T t = count) { }
+```
+The member function `f` of class `X` is defined in global scope; the
+notation `X::f` specifies that the function `f` is a member of class `X`
+and in the scope of class `X`. In the function definition, the parameter
+type `T` refers to the typedef member `T` declared in class `X` and the
+default argument `count` refers to the static data member `count`
+declared in class `X`.
+— *end example*]
+[*Note 4*: A `static` local variable or local type in a member function
+always refers to the same entity, whether or not the member function is
+`inline`. — *end note*]
+Previously declared member functions may be mentioned in `friend`
+declarations.
+Member functions of a local class shall be defined inline in their class
+definition, if they are defined at all.
+[*Note 5*:
+A member function can be declared (but not defined) using a typedef for
+a function type. The resulting member function has exactly the same type
+as it would have if the function declarator were provided explicitly,
+see  [[dcl.fct]]. For example,
+``` cpp
+typedef void fv();
+typedef void fvc() const;
+struct S {
+  fv memfunc1;      // equivalent to: void memfunc1();
+  void memfunc2();
+  fvc memfunc3;     // equivalent to: void memfunc3() const;
+};
+fv  S::* pmfv1 = &S::memfunc1;
+fv  S::* pmfv2 = &S::memfunc2;
+fvc S::* pmfv3 = &S::memfunc3;
+```
+Also see  [[temp.arg]].
+— *end note*]
+### Non-static member functions <a id="class.mfct.non-static">[[class.mfct.non-static]]</a>
+A non-static member function may be called for an object of its class
+type, or for an object of a class derived (Clause  [[class.derived]])
+from its class type, using the class member access syntax (
+[[expr.ref]],  [[over.match.call]]). A non-static member function may
+also be called directly using the function call syntax ([[expr.call]],
+[[over.match.call]]) from within the body of a member function of its
+class or of a class derived from its class.
+If a non-static member function of a class `X` is called for an object
+that is not of type `X`, or of a type derived from `X`, the behavior is
+undefined.
+When an *id-expression* ([[expr.prim]]) that is not part of a class
+member access syntax ([[expr.ref]]) and not used to form a pointer to
+member ([[expr.unary.op]]) is used in a member of class `X` in a
+context where `this` can be used ([[expr.prim.this]]), if name lookup (
+[[basic.lookup]]) resolves the name in the *id-expression* to a
+non-static non-type member of some class `C`, and if either the
+*id-expression* is potentially evaluated or `C` is `X` or a base class
+of `X`, the *id-expression* is transformed into a class member access
+expression ([[expr.ref]]) using `(*this)` ([[class.this]]) as the
+*postfix-expression* to the left of the `.` operator.
+[*Note 1*: If `C` is not `X` or a base class of `X`, the class member
+access expression is ill-formed. — *end note*]
+Similarly during name lookup, when an *unqualified-id* ([[expr.prim]])
+used in the definition of a member function for class `X` resolves to a
+static member, an enumerator or a nested type of class `X` or of a base
+class of `X`, the *unqualified-id* is transformed into a
+*qualified-id* ([[expr.prim]]) in which the *nested-name-specifier*
+names the class of the member function. These transformations do not
+apply in the template definition context ([[temp.dep.type]]).
+[*Example 1*:
+``` cpp
+struct tnode {
+  char tword[20];
+  int count;
+  tnode* left;
+  tnode* right;
+  void set(const char*, tnode* l, tnode* r);
+};
+void tnode::set(const char* w, tnode* l, tnode* r) {
+  count = strlen(w)+1;
+  if (sizeof(tword)<=count)
+      perror("tnode string too long");
+  strcpy(tword,w);
+  left = l;
+  right = r;
+}
+void f(tnode n1, tnode n2) {
+  n1.set("abc",&n2,0);
+  n2.set("def",0,0);
+}
+```
+In the body of the member function `tnode::set`, the member names
+`tword`, `count`, `left`, and `right` refer to members of the object for
+which the function is called. Thus, in the call `n1.set("abc",&n2,0)`,
+`tword` refers to `n1.tword`, and in the call `n2.set("def",0,0)`, it
+refers to `n2.tword`. The functions `strlen`, `perror`, and `strcpy` are
+not members of the class `tnode` and should be declared elsewhere.[^4]
+— *end example*]
+A non-static member function may be declared `const`, `volatile`, or
+`const` `volatile`. These *cv-qualifier*s affect the type of the `this`
+pointer ([[class.this]]). They also affect the function type (
+[[dcl.fct]]) of the member function; a member function declared `const`
+is a *const* member function, a member function declared `volatile` is a
+*volatile* member function and a member function declared `const`
+`volatile` is a *const volatile* member function.
+[*Example 2*:
+``` cpp
+struct X {
+  void g() const;
+  void h() const volatile;
+};
+```
+`X::g` is a `const` member function and `X::h` is a `const` `volatile`
+member function.
+— *end example*]
+A non-static member function may be declared with a *ref-qualifier* (
+[[dcl.fct]]); see  [[over.match.funcs]].
+A non-static member function may be declared *virtual* (
+[[class.virtual]]) or *pure virtual* ([[class.abstract]]).
+#### The `this` pointer <a id="class.this">[[class.this]]</a>
+In the body of a non-static ([[class.mfct]]) member function, the
+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*`.
+[*Note 1*: Thus in a `const` member function, the object for which the
+function is called is accessed through a `const` access
+path. — *end note*]
+[*Example 1*:
+``` cpp
+struct s {
+  int a;
+  int f() const;
+  int g() { return a++; }
+  int h() const { return a++; } // error
+};
+int s::f() const { return a; }
+```
+The `a++` in the body of `s::h` is ill-formed because it tries to modify
+(a part of) the object for which `s::h()` is called. This is not allowed
+in a `const` member function because `this` is a pointer to `const`;
+that is, `*this` has `const` type.
+— *end example*]
+Similarly, `volatile` semantics ([[dcl.type.cv]]) apply in `volatile`
+member functions when accessing the object and its non-static data
+members.
+A cv-qualified member function can be called on an object-expression (
+[[expr.ref]]) only if the object-expression is as cv-qualified or
+less-cv-qualified than the member function.
+[*Example 2*:
+``` cpp
+void k(s& x, const s& y) {
+  x.f();
+  x.g();
+  y.f();
+  y.g();                        // error
+}
+```
+The call `y.g()` is ill-formed because `y` is `const` and `s::g()` is a
+non-`const` member function, that is, `s::g()` is less-qualified than
+the object-expression `y`.
+— *end example*]
+Constructors ([[class.ctor]]) and destructors ([[class.dtor]]) shall
+not be declared `const`, `volatile` or `const` `volatile`.
+[*Note 2*: However, these functions can be invoked to create and
+destroy objects with cv-qualified types, see  [[class.ctor]] and
+[[class.dtor]]. — *end note*]
+### Static members <a id="class.static">[[class.static]]</a>
+A static member `s` of class `X` may be referred to using the
+*qualified-id* expression `X::s`; it is not necessary to use the class
+member access syntax ([[expr.ref]]) to refer to a static member. A
+static member may be referred to using the class member access syntax,
+in which case the object expression is evaluated.
+[*Example 1*:
+``` cpp
+struct process {
+  static void reschedule();
+};
+process& g();
+void f() {
+  process::reschedule();        // OK: no object necessary
+  g().reschedule();             // g() is called
+}
+```
+— *end example*]
+A static member may be referred to directly in the scope of its class or
+in the scope of a class derived (Clause  [[class.derived]]) from its
+class; in this case, the static member is referred to as if a
+*qualified-id* expression was used, with the *nested-name-specifier* of
+the *qualified-id* naming the class scope from which the static member
+is referenced.
+[*Example 2*:
+``` cpp
+int g();
+struct X {
+  static int g();
+};
+struct Y : X {
+  static int i;
+};
+int Y::i = g();                 // equivalent to Y::g();
+```
+— *end example*]
+If an *unqualified-id* ([[expr.prim]]) is used in the definition of a
+static member following the member’s *declarator-id*, and name lookup (
+[[basic.lookup.unqual]]) finds that the *unqualified-id* refers to a
+static member, enumerator, or nested type of the member’s class (or of a
+base class of the member’s class), the *unqualified-id* is transformed
+into a *qualified-id* expression in which the *nested-name-specifier*
+names the class scope from which the member is referenced.
+[*Note 1*: See  [[expr.prim]] for restrictions on the use of non-static
+data members and non-static member functions. — *end note*]
+Static members obey the usual class member access rules (Clause
+[[class.access]]). When used in the declaration of a class member, the
+`static` specifier shall only be used in the member declarations that
+appear within the *member-specification* of the class definition.
+[*Note 2*: It cannot be specified in member declarations that appear in
+namespace scope. — *end note*]
+#### Static member functions <a id="class.static.mfct">[[class.static.mfct]]</a>
+[*Note 1*: The rules described in  [[class.mfct]] apply to static
+member functions. — *end note*]
+[*Note 2*: A static member function does not have a `this` pointer (
+[[class.this]]). — *end note*]
+A static member function shall not be `virtual`. There shall not be a
+static and a non-static member function with the same name and the same
+parameter types ([[over.load]]). A static member function shall not be
+declared `const`, `volatile`, or `const volatile`.
+#### Static data members <a id="class.static.data">[[class.static.data]]</a>
+A static data member is not part of the subobjects of a class. If a
+static data member is declared `thread_local` there is one copy of the
+member per thread. If a static data member is not declared
+`thread_local` there is one copy of the data member that is shared by
+all the objects of the class.
+The declaration of a non-inline static data member in its class
+definition is not a definition and may be of an incomplete type other
+than cv `void`. The definition for a static data member that is not
+defined inline in the class definition shall appear in a namespace scope
+enclosing the member’s class definition. In the definition at namespace
+scope, the name of the static data member shall be qualified by its
+class name using the `::` operator. The *initializer* expression in the
+definition of a static data member is in the scope of its class (
+[[basic.scope.class]]).
+[*Example 1*:
+``` cpp
+class process {
+  static process* run_chain;
+  static process* running;
+};
+process* process::running = get_main();
+process* process::run_chain = running;
+```
+The static data member `run_chain` of class `process` is defined in
+global scope; the notation `process::run_chain` specifies that the
+member `run_chain` is a member of class `process` and in the scope of
+class `process`. In the static data member definition, the *initializer*
+expression refers to the static data member `running` of class
+`process`.
+— *end example*]
+[*Note 1*:
+Once the static data member has been defined, it exists even if no
+objects of its class have been created.
+[*Example 2*:
+In the example above, `run_chain` and `running` exist even if no objects
+of class `process` are created by the program.
+— *end example*]
+— *end note*]
+If a non-volatile non-inline `const` static data member is of integral
+or enumeration type, its declaration in the class definition can specify
+a *brace-or-equal-initializer* in which every *initializer-clause* that
+is an *assignment-expression* is a constant expression (
+[[expr.const]]). The member shall still be defined in a namespace scope
+if it is odr-used ([[basic.def.odr]]) in the program and the namespace
+scope definition shall not contain an *initializer*. An inline static
+data member may be defined in the class definition and may specify a
+*brace-or-equal-initializer*. If the member is declared with the
+`constexpr` specifier, it may be redeclared in namespace scope with no
+initializer (this usage is deprecated; see [[depr.static_constexpr]]).
+Declarations of other static data members shall not specify a
+*brace-or-equal-initializer*.
+[*Note 2*: There shall be exactly one definition of a static data
+member that is odr-used ([[basic.def.odr]]) in a program; no diagnostic
+is required. — *end note*]
+Unnamed classes and classes contained directly or indirectly within
+unnamed classes shall not contain static data members.
+[*Note 3*: Static data members of a class in namespace scope have the
+linkage of that class ([[basic.link]]). A local class cannot have
+static data members ([[class.local]]). — *end note*]
+Static data members are initialized and destroyed exactly like non-local
+variables ([[basic.start.static]], [[basic.start.dynamic]],
+[[basic.start.term]]).
+A static data member shall not be `mutable` ([[dcl.stc]]).
+### Bit-fields <a id="class.bit">[[class.bit]]</a>
+A *member-declarator* of the form
+specifies a bit-field; its length is set off from the bit-field name by
+a colon. The optional *attribute-specifier-seq* appertains to the entity
+being declared. The bit-field attribute is not part of the type of the
+class member. The *constant-expression* shall be an integral constant
+expression with a value greater than or equal to zero. The value of the
+integral constant expression may be larger than the number of bits in
+the object representation ([[basic.types]]) of the bit-field’s type; in
+such cases the extra bits are used as padding bits and do not
+participate in the value representation ([[basic.types]]) of the
+bit-field. Allocation of bit-fields within a class object is
+*implementation-defined*. Alignment of bit-fields is
+*implementation-defined*. Bit-fields are packed into some addressable
+allocation unit.
+[*Note 1*: Bit-fields straddle allocation units on some machines and
+not on others. Bit-fields are assigned right-to-left on some machines,
+left-to-right on others. — *end note*]
+A declaration for a bit-field that omits the *identifier* declares an
+*unnamed bit-field*. Unnamed bit-fields are not members and cannot be
+initialized.
+[*Note 2*: An unnamed bit-field is useful for padding to conform to
+externally-imposed layouts. — *end note*]
+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]]). 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]]).
+[*Note 3*: 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]]. — *end note*]
+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 number of bits in the bit-field is large enough to hold all the
+values of that enumeration type ([[dcl.enum]]), the original enumerator
+value and the value of the bit-field shall compare equal.
+[*Example 1*:
+``` cpp
+enum BOOL { FALSE=0, TRUE=1 };
+struct A {
+  BOOL b:1;
+};
+A a;
+void f() {
+  a.b = TRUE;
+  if (a.b == TRUE)              // yields true
+    { ... }
+}
+```
+— *end example*]
+### Nested class declarations <a id="class.nest">[[class.nest]]</a>
+A class can be declared within another class. A class declared within
+another is called a *nested* class. The name of a nested class is local
+to its enclosing class. The nested class is in the scope of its
+enclosing class.
+[*Note 1*: See  [[expr.prim]] for restrictions on the use of non-static
+data members and non-static member functions. — *end note*]
+[*Example 1*:
+``` cpp
+int x;
+int y;
+struct enclose {
+  int x;
+  static int s;
+  struct inner {
+    void f(int i) {
+      int a = sizeof(x);        // OK: operand of sizeof is an unevaluated operand
+      x = i;                    // error: assign to enclose::x
+      s = i;                    // OK: assign to enclose::s
+      ::x = i;                  // OK: assign to global x
+      y = i;                    // OK: assign to global y
+    }
+    void g(enclose* p, int i) {
+      p->x = i;                 // OK: assign to enclose::x
+    }
+  };
+};
+inner* p = 0;                   // error: inner not in scope
+```
+— *end example*]
+Member functions and static data members of a nested class can be
+defined in a namespace scope enclosing the definition of their class.
+[*Example 2*:
+``` cpp
+struct enclose {
+  struct inner {
+    static int x;
+    void f(int i);
+  };
+};
+int enclose::inner::x = 1;
+void enclose::inner::f(int i) { ... }
+```
+— *end example*]
+If class `X` is defined in a namespace scope, a nested class `Y` may be
+declared in class `X` and later defined in the definition of class `X`
+or be later defined in a namespace scope enclosing the definition of
+class `X`.
+[*Example 3*:
+``` cpp
+class E {
+  class I1;                     // forward declaration of nested class
+  class I2;
+  class I1 { };                 // definition of nested class
+};
+class E::I2 { };                // definition of nested class
+```
+— *end example*]
+Like a member function, a friend function ([[class.friend]]) defined
+within a nested class is in the lexical scope of that class; it obeys
+the same rules for name binding as a static member function of that
+class ([[class.static]]), but it has no special access rights to
+members of an enclosing class.
+### Nested type names <a id="class.nested.type">[[class.nested.type]]</a>
+Type names obey exactly the same scope rules as other names. In
+particular, type names defined within a class definition cannot be used
+outside their class without qualification.
+[*Example 1*:
+``` cpp
+struct X {
+  typedef int I;
+  class Y { ... };
+  I a;
+};
+I b;                            // error
+Y c;                            // error
+X::Y d;                         // OK
+X::I e;                         // OK
+```
+— *end example*]

Diff to HTML by rtfpessoa