[class.static] - C++17 → C++20

Files changed (1) hide show

tmp/tmp1rz7px8f/{from.md → to.md} +30 -43

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

@@ -1,12 +1,12 @@
 ### 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 {
@@ -21,15 +21,15 @@ void f() {
 ```
 — *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();
@@ -42,59 +42,53 @@ struct Y : X {
 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 {
@@ -130,33 +124,26 @@ of class `process` are created by the program.
 — *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]]).

 ### 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 {
 ```
 — *end example*]
 A static member may be referred to directly in the scope of its class or
+in the scope of a class derived [[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();
 int Y::i = g();                 // equivalent to Y::g();
 ```
 — *end example*]
+Static members obey the usual class member access rules
+[[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 1*: 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.
+A static data member shall not be `mutable` [[dcl.stc]]. A static data
+member shall not be a direct member [[class.mem]] of an unnamed
+[[class.pre]] or local [[class.local]] class or of a (possibly
+indirectly) nested class [[class.nest]] thereof.
 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 {
 — *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 is exactly one definition of a static data member that
+is odr-used [[basic.def.odr]] in a valid program. — *end note*]
 [*Note 3*: Static data members of a class in namespace scope have the
+linkage of the name of the class [[basic.link]]. — *end note*]
 Static data members are initialized and destroyed exactly like non-local
 variables ([[basic.start.static]], [[basic.start.dynamic]],
 [[basic.start.term]]).

Diff to HTML by rtfpessoa