[dcl.align] - C++14 → C++17

Files changed (1) hide show

tmp/tmpwinkj5ri/{from.md → to.md} +37 -26

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

@@ -1,11 +1,10 @@
 ### Alignment specifier <a id="dcl.align">[[dcl.align]]</a>
 An *alignment-specifier* may be applied to a variable or to a class data
 member, but it shall not be applied to a bit-field, a function
-parameter, an *exception-declaration* ([[except.handle]]), or a
-variable declared with the `register` storage class specifier. An
 *alignment-specifier* may also be applied to the declaration or
 definition of a class (in an *elaborated-type-specifier* (
 [[dcl.type.elab]]) or *class-head* (Clause  [[class]]), respectively)
 and to the declaration or definition of an enumeration (in an
 *opaque-enum-declaration* or *enum-head*, respectively ([[dcl.enum]])).
@@ -14,69 +13,81 @@ An *alignment-specifier* with an ellipsis is a pack expansion (
 When the *alignment-specifier* is of the form `alignas(`
 *constant-expression* `)`:
 - the *constant-expression* shall be an integral constant expression
-- if the constant expression evaluates to a fundamental alignment, the
- alignment requirement of the declared entity shall be the specified
-  fundamental alignment
-- if the constant expression evaluates to an extended alignment and the
-  implementation supports that alignment in the context of the
-  declaration, the alignment of the declared entity shall be that
-  alignment
-- if the constant expression evaluates to an extended alignment and the
   implementation does not support that alignment in the context of the
-  declaration, the program is ill-formed
-- if the constant expression evaluates to zero, the alignment specifier
-  shall have no effect
-- otherwise, the program is ill-formed.
-When the *alignment-specifier* is of the form `alignas(` *type-id* `)`,
-it shall have the same effect as `alignas({}alignof(`*type-id*`))` (
-[[expr.alignof]]).
-When multiple *alignment-specifier*s are specified for an entity, the
-alignment requirement shall be set to the strictest specified alignment.
 The combined effect of all *alignment-specifier*s in a declaration shall
 not specify an alignment that is less strict than the alignment that
 would be required for the entity being declared if all
-*alignment-specifier*s were omitted (including those in other
-declarations).
 If the defining declaration of an entity has an *alignment-specifier*,
 any non-defining declaration of that entity shall either specify
 equivalent alignment or have no *alignment-specifier*. Conversely, if
 any declaration of an entity has an *alignment-specifier*, every
 defining declaration of that entity shall specify an equivalent
 alignment. No diagnostic is required if declarations of an entity have
 different *alignment-specifier*s in different translation units.
 ``` cpp
 // Translation unit #1:
-struct S { int x; } s, p = &s;
 // Translation unit #2:
-struct alignas(16) S;           // error: definition of S lacks alignment; no
-extern S* p;                    // diagnostic required
 ```
 An aligned buffer with an alignment requirement of `A` and holding `N`
-elements of type `T` other than `char`, `signed char`, or
-`unsigned char` can be declared as:
 ``` cpp
 alignas(T) alignas(A) T buffer[N];
 ```
 Specifying `alignas(T)` ensures that the final requested alignment will
 not be weaker than `alignof(T)`, and therefore the program will not be
 ill-formed.
 ``` cpp
 alignas(double) void f();                           // error: alignment applied to function
 alignas(double) unsigned char c[sizeof(double)];    // array of characters, suitably aligned for a double
 extern unsigned char c[sizeof(double)];             // no alignas necessary
 alignas(float)
   extern unsigned char c[sizeof(double)];           // error: different alignment in declaration
 ```

 ### Alignment specifier <a id="dcl.align">[[dcl.align]]</a>
 An *alignment-specifier* may be applied to a variable or to a class data
 member, but it shall not be applied to a bit-field, a function
+parameter, or an *exception-declaration* ([[except.handle]]). An
 *alignment-specifier* may also be applied to the declaration or
 definition of a class (in an *elaborated-type-specifier* (
 [[dcl.type.elab]]) or *class-head* (Clause  [[class]]), respectively)
 and to the declaration or definition of an enumeration (in an
 *opaque-enum-declaration* or *enum-head*, respectively ([[dcl.enum]])).
 When the *alignment-specifier* is of the form `alignas(`
 *constant-expression* `)`:
 - the *constant-expression* shall be an integral constant expression
+- if the constant expression does not evaluate to an alignment value (
+ [[basic.align]]), or evaluates to an extended alignment and the
   implementation does not support that alignment in the context of the
+  declaration, the program is ill-formed.
+An *alignment-specifier* of the form `alignas(` *type-id* `)` has the
+same effect as `alignas({}alignof(` *type-id* `))` ([[expr.alignof]]).
+The alignment requirement of an entity is the strictest nonzero
+alignment specified by its *alignment-specifier*s, if any; otherwise,
+the *alignment-specifier*s have no effect.
 The combined effect of all *alignment-specifier*s in a declaration shall
 not specify an alignment that is less strict than the alignment that
 would be required for the entity being declared if all
+*alignment-specifier*s appertaining to that entity were omitted.
+[*Example 1*:
+``` cpp
+struct alignas(8) S {};
+struct alignas(1) U {
+  S s;
+};  // error: U specifies an alignment that is less strict than if the alignas(1) were omitted.
+```
+— *end example*]
 If the defining declaration of an entity has an *alignment-specifier*,
 any non-defining declaration of that entity shall either specify
 equivalent alignment or have no *alignment-specifier*. Conversely, if
 any declaration of an entity has an *alignment-specifier*, every
 defining declaration of that entity shall specify an equivalent
 alignment. No diagnostic is required if declarations of an entity have
 different *alignment-specifier*s in different translation units.
+[*Example 2*:
 ``` cpp
 // Translation unit #1:
+struct S { int x; } s, *p = &s;
 // Translation unit #2:
+struct alignas(16) S;           // error: definition of S lacks alignment, no diagnostic required
+extern S* p;
 ```
+— *end example*]
+[*Example 3*:
 An aligned buffer with an alignment requirement of `A` and holding `N`
+elements of type `T` can be declared as:
 ``` cpp
 alignas(T) alignas(A) T buffer[N];
 ```
 Specifying `alignas(T)` ensures that the final requested alignment will
 not be weaker than `alignof(T)`, and therefore the program will not be
 ill-formed.
+— *end example*]
+[*Example 4*:
 ``` cpp
 alignas(double) void f();                           // error: alignment applied to function
 alignas(double) unsigned char c[sizeof(double)];    // array of characters, suitably aligned for a double
 extern unsigned char c[sizeof(double)];             // no alignas necessary
 alignas(float)
   extern unsigned char c[sizeof(double)];           // error: different alignment in declaration
 ```
+— *end example*]

Diff to HTML by rtfpessoa