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

Files changed (1) hide show

tmp/tmp9zl4h7fk/{from.md → to.md} +91 -46

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

@@ -1,9 +1,9 @@
 ## Enumeration declarations <a id="dcl.enum">[[dcl.enum]]</a>
 An enumeration is a distinct type ([[basic.compound]]) with named
-constants. Its name becomes an *enum-name*, within its scope.
 ``` bnf
 enum-name:
     identifier
 ```
@@ -14,18 +14,21 @@ enum-specifier:
     enum-head '{' enumerator-list ', }'
 ```
 ``` bnf
 enum-head:
-    enum-key attribute-specifier-seqₒₚₜ identifierₒₚₜ enum-baseₒₚₜ
-    enum-key attribute-specifier-seqₒₚₜ nested-name-specifier identifier
-  enum-baseₒₚₜ
 ```
 ``` bnf
 opaque-enum-declaration:
-    enum-key attribute-specifier-seqₒₚₜ identifier enum-baseₒₚₜ ';'
 ```
 ``` bnf
 enum-key:
     'enum'
@@ -50,61 +53,85 @@ enumerator-definition:
     enumerator '=' constant-expression
 ```
 ``` bnf
 enumerator:
-    identifier
 ```
 The optional *attribute-specifier-seq* in the *enum-head* and the
 *opaque-enum-declaration* appertains to the enumeration; the attributes
 in that *attribute-specifier-seq* are thereafter considered attributes
 of the enumeration whenever it is named. A `:` following “`enum`
-*identifier*” is parsed as part of an *enum-base*. This resolves a
-potential ambiguity between the declaration of an enumeration with an
-*enum-base* and the declaration of an unnamed bit-field of enumeration
-type.
 ``` cpp
    struct S {
      enum E : int {};
      enum E : int {};           // error: redeclaration of enumeration
    };
 ```
 The enumeration type declared with an *enum-key* of only `enum` is an
-unscoped enumeration, and its *enumerator*s are *unscoped enumerators*.
-The *enum-key*s `enum class` and `enum struct` are semantically
-equivalent; an enumeration type declared with one of these is a *scoped
-enumeration*, and its *enumerator*s are *scoped enumerators*. The
-optional *identifier* shall not be omitted in the declaration of a
-scoped enumeration. The *type-specifier-seq* of an *enum-base* shall
-name an integral type; any cv-qualification is ignored. An
-*opaque-enum-declaration* declaring an unscoped enumeration shall not
-omit the *enum-base*. The identifiers in an *enumerator-list* are
-declared as constants, and can appear wherever constants are required.
-An *enumerator-definition* with `=` gives the associated *enumerator*
-the value indicated by the *constant-expression*. If the first
-*enumerator* has no *initializer*, the value of the corresponding
 constant is zero. An *enumerator-definition* without an *initializer*
 gives the *enumerator* the value obtained by increasing the value of the
 previous *enumerator* by one.
 ``` cpp
 enum { a, b, c=0 };
 enum { d, e, f=e+2 };
 ```
 defines `a`, `c`, and `d` to be zero, `b` and `e` to be `1`, and `f` to
 be `3`.
 An *opaque-enum-declaration* is either a redeclaration of an enumeration
-in the current scope or a declaration of a new enumeration. An
-enumeration declared by an *opaque-enum-declaration* has fixed
-underlying type and is a complete type. The list of enumerators can be
-provided in a later redeclaration with an *enum-specifier*. A scoped
-enumeration shall not be later redeclared as unscoped or with a
 different underlying type. An unscoped enumeration shall not be later
 redeclared as scoped and each redeclaration shall include an *enum-base*
 specifying the same underlying type as in the original declaration.
 If the *enum-key* is followed by a *nested-name-specifier*, the
@@ -113,12 +140,12 @@ declared directly in the class or namespace to which the
 *nested-name-specifier* refers (i.e., neither inherited nor introduced
 by a *using-declaration*), and the *enum-specifier* shall appear in a
 namespace enclosing the previous declaration.
 Each enumeration defines a type that is different from all other types.
-Each enumeration also has an underlying type. The underlying type can be
-explicitly specified using an *enum-base*. For a scoped enumeration
 type, the underlying type is `int` if it is not explicitly specified. In
 both of these cases, the underlying type is said to be *fixed*.
 Following the closing brace of an *enum-specifier*, each enumerator has
 the type of its enumeration. If the underlying type is fixed, the type
 of each enumerator prior to the closing brace is the underlying type and
@@ -158,29 +185,31 @@ unless the value of an enumerator cannot fit in an `int` or
 is as if the enumeration had a single enumerator with value 0.
 For an enumeration whose underlying type is fixed, the values of the
 enumeration are the values of the underlying type. Otherwise, for an
 enumeration where eₘin is the smallest enumerator and eₘax is the
-largest, the values of the enumeration are the values in the range bₘᵢₙ
-to bₘₐₓ, defined as follows: Let K be 1 for a two’s complement
-representation and 0 for a one’s complement or sign-magnitude
-representation. bₘₐₓ is the smallest value greater than or equal to
-max(|eₘᵢₙ| - K, |eₘₐₓ|) and equal to $2^M-1$, where M is a non-negative
-integer. bₘᵢₙ is zero if eₘᵢₙ is non-negative and -(bₘₐₓ+K) otherwise.
 The size of the smallest bit-field large enough to hold all the values
-of the enumeration type is max(M,1) if bₘᵢₙ is zero and M+1 otherwise.
 It is possible to define an enumeration that has values not defined by
 any of its enumerators. If the *enumerator-list* is empty, the values of
 the enumeration are as if the enumeration had a single enumerator with
 value 0.[^4]
-Two enumeration types are *layout-compatible* if they have the same
-*underlying type*.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion ([[conv.prom]]).
 ``` cpp
   enum color { red, yellow, green=20, blue };
   color col = red;
   color* cp = &col;
   if (*cp == blue)              // ...
@@ -192,15 +221,12 @@ type. The possible values of an object of type `color` are `red`,
 `yellow`, `green`, `blue`; these values can be converted to the integral
 values `0`, `1`, `20`, and `21`. Since enumerations are distinct types,
 objects of type `color` can be assigned only values of type `color`.
 ``` cpp
-color c = 1;                    // error: type mismatch,
- // no conversion from int to color
-int i = yellow;                 // OK: yellow converted to integral value 1
-                                // integral promotion
 ```
 Note that this implicit `enum` to `int` conversion is not provided for a
 scoped enumeration:
@@ -209,15 +235,18 @@ enum class Col { red, yellow, green };
 int x = Col::red;               // error: no Col to int conversion
 Col y = Col::red;
 if (y) { }                      // error: no Col to bool conversion
 ```
 Each *enum-name* and each unscoped *enumerator* is declared in the scope
 that immediately contains the *enum-specifier*. Each scoped *enumerator*
 is declared in the scope of the enumeration. These names obey the scope
-rules defined for all names in ([[basic.scope]]) and (
-[[basic.lookup]]).
 ``` cpp
 enum direction { left='l', right='r' };
 void g()  {
@@ -233,14 +262,18 @@ void h()  {
   a = high;                     // error: high not in scope
   a = altitude::low;            // OK
 }
 ```
 An enumerator declared in class scope can be referred to using the class
 member access operators (`::`, `.` (dot) and `->` (arrow)), see
 [[expr.ref]].
 ``` cpp
 struct X {
   enum direction { left='l', right='r' };
   int f(int i) { return i==left ? 0 : i==right ? 1 : 2; }
 };
@@ -253,5 +286,17 @@ void g(X* p) {
   i = p->f(p->left);            // OK
   // ...
 }
 ```

 ## Enumeration declarations <a id="dcl.enum">[[dcl.enum]]</a>
 An enumeration is a distinct type ([[basic.compound]]) with named
+constants. Its name becomes an *enum-name* within its scope.
 ``` bnf
 enum-name:
     identifier
 ```
     enum-head '{' enumerator-list ', }'
 ```
 ``` bnf
 enum-head:
+    enum-key attribute-specifier-seqₒₚₜ enum-head-nameₒₚₜ enum-baseₒₚₜ
+```
+``` bnf
+enum-head-name:
+    nested-name-specifierₒₚₜ identifier
 ```
 ``` bnf
 opaque-enum-declaration:
+    enum-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier enum-baseₒₚₜ ';'
 ```
 ``` bnf
 enum-key:
     'enum'
     enumerator '=' constant-expression
 ```
 ``` bnf
 enumerator:
+    identifier attribute-specifier-seqₒₚₜ
 ```
 The optional *attribute-specifier-seq* in the *enum-head* and the
 *opaque-enum-declaration* appertains to the enumeration; the attributes
 in that *attribute-specifier-seq* are thereafter considered attributes
 of the enumeration whenever it is named. A `:` following “`enum`
+*nested-name-specifier*ₒₚₜ  *identifier*” within the
+*decl-specifier-seq* of a *member-declaration* is parsed as part of an
+*enum-base*.
+[*Note 1*:
+This resolves a potential ambiguity between the declaration of an
+enumeration with an *enum-base* and the declaration of an unnamed
+bit-field of enumeration type.
+[*Example 1*:
 ``` cpp
    struct S {
      enum E : int {};
      enum E : int {};           // error: redeclaration of enumeration
    };
 ```
+— *end example*]
+— *end note*]
+If an *opaque-enum-declaration* contains a *nested-name-specifier*, the
+declaration shall be an explicit specialization ([[temp.expl.spec]]).
 The enumeration type declared with an *enum-key* of only `enum` is an
+*unscoped enumeration*, and its *enumerator*s are *unscoped
+enumerators*. The *enum-key*s `enum class` and `enum struct` are
+semantically equivalent; an enumeration type declared with one of these
+is a *scoped enumeration*, and its *enumerator*s are *scoped
+enumerators*. The optional *identifier* shall not be omitted in the
+declaration of a scoped enumeration. The *type-specifier-seq* of an
+*enum-base* shall name an integral type; any cv-qualification is
+ignored. An *opaque-enum-declaration* declaring an unscoped enumeration
+shall not omit the *enum-base*. The identifiers in an *enumerator-list*
+are declared as constants, and can appear wherever constants are
+required. An *enumerator-definition* with `=` gives the associated
+*enumerator* the value indicated by the *constant-expression*. If the
+first *enumerator* has no *initializer*, the value of the corresponding
 constant is zero. An *enumerator-definition* without an *initializer*
 gives the *enumerator* the value obtained by increasing the value of the
 previous *enumerator* by one.
+[*Example 2*:
 ``` cpp
 enum { a, b, c=0 };
 enum { d, e, f=e+2 };
 ```
 defines `a`, `c`, and `d` to be zero, `b` and `e` to be `1`, and `f` to
 be `3`.
+— *end example*]
+The optional *attribute-specifier-seq* in an *enumerator* appertains to
+that enumerator.
 An *opaque-enum-declaration* is either a redeclaration of an enumeration
+in the current scope or a declaration of a new enumeration.
+[*Note 2*: An enumeration declared by an *opaque-enum-declaration* has
+fixed underlying type and is a complete type. The list of enumerators
+can be provided in a later redeclaration with an
+*enum-specifier*. — *end note*]
+A scoped enumeration shall not be later redeclared as unscoped or with a
 different underlying type. An unscoped enumeration shall not be later
 redeclared as scoped and each redeclaration shall include an *enum-base*
 specifying the same underlying type as in the original declaration.
 If the *enum-key* is followed by a *nested-name-specifier*, the
 *nested-name-specifier* refers (i.e., neither inherited nor introduced
 by a *using-declaration*), and the *enum-specifier* shall appear in a
 namespace enclosing the previous declaration.
 Each enumeration defines a type that is different from all other types.
+Each enumeration also has an *underlying type*. The underlying type can
+be explicitly specified using an *enum-base*. For a scoped enumeration
 type, the underlying type is `int` if it is not explicitly specified. In
 both of these cases, the underlying type is said to be *fixed*.
 Following the closing brace of an *enum-specifier*, each enumerator has
 the type of its enumeration. If the underlying type is fixed, the type
 of each enumerator prior to the closing brace is the underlying type and
 is as if the enumeration had a single enumerator with value 0.
 For an enumeration whose underlying type is fixed, the values of the
 enumeration are the values of the underlying type. Otherwise, for an
 enumeration where eₘin is the smallest enumerator and eₘax is the
+largest, the values of the enumeration are the values in the range bₘin
+to bₘax, defined as follows: Let K be 1 for a two’s complement
+representation and 0 for a ones’ complement or sign-magnitude
+representation. bₘax is the smallest value greater than or equal to
+max(|eₘin| - K, |eₘax|) and equal to $2^M-1$, where M is a non-negative
+integer. bₘin is zero if eₘin is non-negative and -(bₘax+K) otherwise.
 The size of the smallest bit-field large enough to hold all the values
+of the enumeration type is max(M,1) if bₘin is zero and M+1 otherwise.
 It is possible to define an enumeration that has values not defined by
 any of its enumerators. If the *enumerator-list* is empty, the values of
 the enumeration are as if the enumeration had a single enumerator with
 value 0.[^4]
+Two enumeration types are *layout-compatible enumerations* if they have
+the same underlying type.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion ([[conv.prom]]).
+[*Example 3*:
 ``` cpp
   enum color { red, yellow, green=20, blue };
   color col = red;
   color* cp = &col;
   if (*cp == blue)              // ...
 `yellow`, `green`, `blue`; these values can be converted to the integral
 values `0`, `1`, `20`, and `21`. Since enumerations are distinct types,
 objects of type `color` can be assigned only values of type `color`.
 ``` cpp
+color c = 1;                    // error: type mismatch, no conversion from int to color
+int i = yellow;                 // OK: yellow converted to integral value 1, integral promotion
 ```
 Note that this implicit `enum` to `int` conversion is not provided for a
 scoped enumeration:
 int x = Col::red;               // error: no Col to int conversion
 Col y = Col::red;
 if (y) { }                      // error: no Col to bool conversion
 ```
+— *end example*]
 Each *enum-name* and each unscoped *enumerator* is declared in the scope
 that immediately contains the *enum-specifier*. Each scoped *enumerator*
 is declared in the scope of the enumeration. These names obey the scope
+rules defined for all names in  [[basic.scope]] and  [[basic.lookup]].
+[*Example 4*:
 ``` cpp
 enum direction { left='l', right='r' };
 void g()  {
   a = high;                     // error: high not in scope
   a = altitude::low;            // OK
 }
 ```
+— *end example*]
 An enumerator declared in class scope can be referred to using the class
 member access operators (`::`, `.` (dot) and `->` (arrow)), see
 [[expr.ref]].
+[*Example 5*:
 ``` cpp
 struct X {
   enum direction { left='l', right='r' };
   int f(int i) { return i==left ? 0 : i==right ? 1 : 2; }
 };
   i = p->f(p->left);            // OK
   // ...
 }
 ```
+— *end example*]
+If an *enum-head* contains a *nested-name-specifier*, the
+*enum-specifier* shall refer to an enumeration that was previously
+declared directly in the class or namespace to which the
+*nested-name-specifier* refers, or in an element of the inline namespace
+set ([[namespace.def]]) of that namespace (i.e., not merely inherited
+or introduced by a *using-declaration*), and the *enum-specifier* shall
+appear in a namespace enclosing the previous declaration. In such cases,
+the *nested-name-specifier* of the *enum-head* of the definition shall
+not begin with a *decltype-specifier*.

Diff to HTML by rtfpessoa