[dcl.stc] - C++17 → C++20

Files changed (1) hide show

tmp/tmpitr_upch/{from.md → to.md} +42 -39

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

@@ -2,69 +2,71 @@
 The storage class specifiers are
 ``` bnf
 storage-class-specifier:
- 'static'
- 'thread_local'
- 'extern'
- 'mutable'
 ```
 At most one *storage-class-specifier* shall appear in a given
 *decl-specifier-seq*, except that `thread_local` may appear with
 `static` or `extern`. If `thread_local` appears in any declaration of a
 variable it shall be present in all declarations of that entity. If a
 *storage-class-specifier* appears in a *decl-specifier-seq*, there can
 be no `typedef` specifier in the same *decl-specifier-seq* and the
 *init-declarator-list* or *member-declarator-list* of the declaration
 shall not be empty (except for an anonymous union declared in a named
-namespace or in the global namespace, which shall be declared `static` (
-[[class.union.anon]])). The *storage-class-specifier* applies to the
-name declared by each *init-declarator* in the list and not to any names
-declared by other specifiers. A *storage-class-specifier* other than
-`thread_local` shall not be specified in an explicit specialization (
-[[temp.expl.spec]]) or an explicit instantiation ([[temp.explicit]])
-directive.
-[*Note 1*: A variable declared without a *storage-class-specifier* at
 block scope or declared as a function parameter has automatic storage
-duration by default ([[basic.stc.auto]]). — *end note*]
 The `thread_local` specifier indicates that the named entity has thread
-storage duration ([[basic.stc.thread]]). It shall be applied only to
-the names of variables of namespace or block scope and to the names of
-static data members. When `thread_local` is applied to a variable of
 block scope the *storage-class-specifier* `static` is implied if no
 other *storage-class-specifier* appears in the *decl-specifier-seq*.
-The `static` specifier can be applied only to names of variables and
-functions and to anonymous unions ([[class.union.anon]]). There can be
-no `static` function declarations within a block, nor any `static`
-function parameters. A `static` specifier used in the declaration of a
-variable declares the variable to have static storage duration (
-[[basic.stc.static]]), unless accompanied by the `thread_local`
-specifier, which declares the variable to have thread storage duration (
-[[basic.stc.thread]]). A `static` specifier can be used in declarations
-of class members;  [[class.static]] describes its effect. For the
-linkage of a name declared with a `static` specifier, see
-[[basic.link]].
-The `extern` specifier can be applied only to the names of variables and
-functions. The `extern` specifier cannot be used in the declaration of
-class members or function parameters. For the linkage of a name declared
-with an `extern` specifier, see  [[basic.link]].
-[*Note 2*: The `extern` keyword can also be used in
 *explicit-instantiation*s and *linkage-specification*s, but it is not a
 *storage-class-specifier* in such contexts. — *end note*]
 The linkages implied by successive declarations for a given entity shall
 agree. That is, within a given scope, each declaration declaring the
 same variable name or the same overloading of a function name shall
-imply the same linkage. Each function in a given set of overloaded
-functions can have a different linkage, however.
 [*Example 1*:
 ``` cpp
 static char* f();               // f() has internal linkage
@@ -121,24 +123,25 @@ void h() {
 ```
 — *end example*]
 The `mutable` specifier shall appear only in the declaration of a
-non-static data member ([[class.mem]]) whose type is neither
 const-qualified nor a reference type.
 [*Example 3*:
 ``` cpp
 class X {
   mutable const int* p;         // OK
-  mutable int* const q;         // ill-formed
 };
 ```
 — *end example*]
-The `mutable` specifier on a class data member nullifies a `const`
-specifier applied to the containing class object and permits
 modification of the mutable class member even though the rest of the
-object is `const` ([[dcl.type.cv]]).

 The storage class specifiers are
 ``` bnf
 storage-class-specifier:
+    static
+    thread_local
+    extern
+    mutable
 ```
 At most one *storage-class-specifier* shall appear in a given
 *decl-specifier-seq*, except that `thread_local` may appear with
 `static` or `extern`. If `thread_local` appears in any declaration of a
 variable it shall be present in all declarations of that entity. If a
 *storage-class-specifier* appears in a *decl-specifier-seq*, there can
 be no `typedef` specifier in the same *decl-specifier-seq* and the
 *init-declarator-list* or *member-declarator-list* of the declaration
 shall not be empty (except for an anonymous union declared in a named
+namespace or in the global namespace, which shall be declared `static`
+[[class.union.anon]]). The *storage-class-specifier* applies to the name
+declared by each *init-declarator* in the list and not to any names
+declared by other specifiers.
+[*Note 1*: See [[temp.expl.spec]] and [[temp.explicit]] for
+restrictions in explicit specializations and explicit instantiations,
+respectively. — *end note*]
+[*Note 2*: A variable declared without a *storage-class-specifier* at
 block scope or declared as a function parameter has automatic storage
+duration by default [[basic.stc.auto]]. — *end note*]
 The `thread_local` specifier indicates that the named entity has thread
+storage duration [[basic.stc.thread]]. It shall be applied only to the
+declaration of a variable of namespace or block scope, to a structured
+binding declaration [[dcl.struct.bind]], or to the declaration of a
+static data member. When `thread_local` is applied to a variable of
 block scope the *storage-class-specifier* `static` is implied if no
 other *storage-class-specifier* appears in the *decl-specifier-seq*.
+The `static` specifier shall be applied only to the declaration of a
+variable or function, to a structured binding declaration
+[[dcl.struct.bind]], or to the declaration of an anonymous union
+[[class.union.anon]]. There can be no `static` function declarations
+within a block, nor any `static` function parameters. A `static`
+specifier used in the declaration of a variable declares the variable to
+have static storage duration [[basic.stc.static]], unless accompanied by
+the `thread_local` specifier, which declares the variable to have thread
+storage duration [[basic.stc.thread]]. A `static` specifier can be used
+in declarations of class members;  [[class.static]] describes its
+effect. For the linkage of a name declared with a `static` specifier,
+see  [[basic.link]].
+The `extern` specifier shall be applied only to the declaration of a
+variable or function. The `extern` specifier shall not be used in the
+declaration of a class member or function parameter. For the linkage of
+a name declared with an `extern` specifier, see  [[basic.link]].
+[*Note 3*: The `extern` keyword can also be used in
 *explicit-instantiation*s and *linkage-specification*s, but it is not a
 *storage-class-specifier* in such contexts. — *end note*]
 The linkages implied by successive declarations for a given entity shall
 agree. That is, within a given scope, each declaration declaring the
 same variable name or the same overloading of a function name shall
+imply the same linkage.
 [*Example 1*:
 ``` cpp
 static char* f();               // f() has internal linkage
 ```
 — *end example*]
 The `mutable` specifier shall appear only in the declaration of a
+non-static data member [[class.mem]] whose type is neither
 const-qualified nor a reference type.
 [*Example 3*:
 ``` cpp
 class X {
   mutable const int* p;         // OK
+  mutable int* const q;         // error
 };
 ```
 — *end example*]
+[*Note 4*: The `mutable` specifier on a class data member nullifies a
+`const` specifier applied to the containing class object and permits
 modification of the mutable class member even though the rest of the
+object is const ([[basic.type.qualifier]],
+[[dcl.type.cv]]). — *end note*]

Diff to HTML by rtfpessoa