[basic.fundamental] - C++23 → Trunk

Files changed (1) hide show

tmp/tmprq6caj24/{from.md → to.md} +135 -27

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

@@ -4,12 +4,12 @@ There are five *standard signed integer types*: “`signed char`”,
 “`short int`”, “`int`”, “`long int`”, and “`long long int`”. In this
 list, each type provides at least as much storage as those preceding it
 in the list. There may also be *implementation-defined* *extended signed
 integer types*. The standard and extended signed integer types are
 collectively called *signed integer types*. The range of representable
-values for a signed integer type is -2ᴺ⁻¹ to 2ᴺ⁻¹-1 (inclusive), where
-*N* is called the *width* of the type.
 [*Note 1*: Plain `int`s are intended to have the natural width
 suggested by the architecture of the execution environment; the other
 signed integer types are provided to meet special needs. — *end note*]
@@ -31,11 +31,11 @@ arithmetic yields undefined behavior [[expr.pre]]. — *end note*]
 An unsigned integer type has the same object representation, value
 representation, and alignment requirements [[basic.align]] as the
 corresponding signed integer type. For each value x of a signed integer
 type, the value of the corresponding unsigned integer type congruent to
 x modulo 2ᴺ has the same value of corresponding bits in its value
-representation.[^18]
 [*Example 1*: The value -1 of a signed integer type has the same
 representation as the largest value of the corresponding unsigned
 type. — *end example*]
@@ -48,22 +48,22 @@ type. — *end example*]
 | `int`           | 16                |
 | `long int`      | 32                |
 | `long long int` | 64                |
-The width of each signed integer type shall not be less than the values
-specified in [[basic.fundamental.width]]. The value representation of a
-signed or unsigned integer type comprises N bits, where N is the
-respective width. Each set of values for any padding bits
 [[basic.types.general]] in the object representation are alternative
 representations of the value specified by the value representation.
 [*Note 3*: Padding bits have unspecified value, but cannot cause traps.
-In contrast, see ISO C 6.2.6.2. — *end note*]
 [*Note 4*: The signed and unsigned integer types satisfy the
-constraints given in ISO C 5.2.4.2.1. — *end note*]
 Except as specified above, the width of a signed or unsigned integer
 type is *implementation-defined*.
 Each value x of an unsigned integer type with width N has a unique
@@ -101,12 +101,12 @@ than the width of that type has padding bits; see
 Type `wchar_t` is a distinct type that has an *implementation-defined*
 signed or unsigned integer type as its underlying type.
 Type `char8_t` denotes a distinct type whose underlying type is
 `unsigned char`. Types `char16_t` and `char32_t` denote distinct types
-whose underlying types are `uint_least16_t` and `uint_least32_t`,
-respectively, in `<cstdint>`.
 Type `bool` is a distinct type that has the same object representation,
 value representation, and alignment requirements as an
 *implementation-defined* unsigned integer type. The values of type
 `bool` are `true` and `false`.
@@ -146,36 +146,144 @@ interactions with floating-point types. — *end note*]
 Except as specified in [[basic.extended.fp]], the object and value
 representations and accuracy of operations of floating-point types are
 *implementation-defined*.
 Integral and floating-point types are collectively termed *arithmetic
 types*.
-[*Note 10*: Properties of the arithmetic types, such as their minimum
 and maximum representable value, can be queried using the facilities in
 the standard library headers `<limits>`, `<climits>`, and
 `<cfloat>`. — *end note*]
 A type cv `void` is an incomplete type that cannot be completed; such a
 type has an empty set of values. It is used as the return type for
-functions that do not return a value. Any expression can be explicitly
-converted to type cv `void`
-[[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]. An expression
-of type cv `void` shall be used only as an expression statement
-[[stmt.expr]], as an operand of a comma expression [[expr.comma]], as a
-second or third operand of `?:` [[expr.cond]], as the operand of
-`typeid`, `noexcept`, or `decltype`, as the expression in a `return`
-statement [[stmt.return]] for a function with the return type cv `void`,
-or as the operand of an explicit conversion to type cv `void`.
-A value of type `std::nullptr_t` is a null pointer constant
-[[conv.ptr]]. Such values participate in the pointer and the
-pointer-to-member conversions [[conv.ptr]], [[conv.mem]].
-`sizeof(std::nullptr_t)` shall be equal to `sizeof(void*)`.
 The types described in this subclause are called *fundamental types*.
-[*Note 11*: Even if the implementation defines two or more fundamental
 types to have the same value representation, they are nevertheless
 different types. — *end note*]

 “`short int`”, “`int`”, “`long int`”, and “`long long int`”. In this
 list, each type provides at least as much storage as those preceding it
 in the list. There may also be *implementation-defined* *extended signed
 integer types*. The standard and extended signed integer types are
 collectively called *signed integer types*. The range of representable
+values for a signed integer type is -2ᴺ⁻¹ to 2ᴺ⁻¹-1 (inclusive), where N
+is called the *width* of the type.
 [*Note 1*: Plain `int`s are intended to have the natural width
 suggested by the architecture of the execution environment; the other
 signed integer types are provided to meet special needs. — *end note*]
 An unsigned integer type has the same object representation, value
 representation, and alignment requirements [[basic.align]] as the
 corresponding signed integer type. For each value x of a signed integer
 type, the value of the corresponding unsigned integer type congruent to
 x modulo 2ᴺ has the same value of corresponding bits in its value
+representation.[^16]
 [*Example 1*: The value -1 of a signed integer type has the same
 representation as the largest value of the corresponding unsigned
 type. — *end example*]
 | `int`           | 16                |
 | `long int`      | 32                |
 | `long long int` | 64                |
+The width of each standard signed integer type shall not be less than
+the values specified in [[basic.fundamental.width]]. The value
+representation of a signed or unsigned integer type comprises N bits,
+where N is the respective width. Each set of values for any padding bits
 [[basic.types.general]] in the object representation are alternative
 representations of the value specified by the value representation.
 [*Note 3*: Padding bits have unspecified value, but cannot cause traps.
+In contrast, see ISO/IEC 9899:2018 (C) 6.2.6.2. — *end note*]
 [*Note 4*: The signed and unsigned integer types satisfy the
+constraints given in ISO/IEC 9899:2018 (C) 5.3.5.3.2. — *end note*]
 Except as specified above, the width of a signed or unsigned integer
 type is *implementation-defined*.
 Each value x of an unsigned integer type with width N has a unique
 Type `wchar_t` is a distinct type that has an *implementation-defined*
 signed or unsigned integer type as its underlying type.
 Type `char8_t` denotes a distinct type whose underlying type is
 `unsigned char`. Types `char16_t` and `char32_t` denote distinct types
+whose underlying types are `std::uint_least16_t` and
+`std::uint_least32_t`, respectively, in `<cstdint>`.
 Type `bool` is a distinct type that has the same object representation,
 value representation, and alignment requirements as an
 *implementation-defined* unsigned integer type. The values of type
 `bool` are `true` and `false`.
 Except as specified in [[basic.extended.fp]], the object and value
 representations and accuracy of operations of floating-point types are
 *implementation-defined*.
+The minimum range of representable values for a floating-point type is
+the most negative finite floating-point number representable in that
+type through the most positive finite floating-point number
+representable in that type. In addition, if negative infinity is
+representable in a type, the range of that type is extended to all
+negative real numbers; likewise, if positive infinity is representable
+in a type, the range of that type is extended to all positive real
+numbers.
+[*Note 10*: Since negative and positive infinity are representable in
+ISO/IEC 60559 formats, all real numbers lie within the range of
+representable values of a floating-point type adhering to ISO/IEC
+60559. — *end note*]
 Integral and floating-point types are collectively termed *arithmetic
 types*.
+[*Note 11*: Properties of the arithmetic types, such as their minimum
 and maximum representable value, can be queried using the facilities in
 the standard library headers `<limits>`, `<climits>`, and
 `<cfloat>`. — *end note*]
 A type cv `void` is an incomplete type that cannot be completed; such a
 type has an empty set of values. It is used as the return type for
+functions that do not return a value. An expression of type cv `void`
+shall be used only as
+- an expression statement [[stmt.expr]],
+- the expression in a `return` statement [[stmt.return]] for a function
+  with the return type cv `void`,
+- an operand of a comma expression [[expr.comma]],
+- the second or third operand of `?:` [[expr.cond]],
+- the operand of a `typeid` expression [[expr.typeid]],
+- the operand of a `noexcept` operator [[expr.unary.noexcept]],
+- the operand of a `decltype` specifier [[dcl.type.decltype]], or
+- the operand of an explicit conversion to type cv `void`
+ [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]].
+The types denoted by cv `std::nullptr_t` are distinct types. A prvalue
+of type `std::nullptr_t` is a null pointer constant [[conv.ptr]]. Such
+values participate in the pointer and the pointer-to-member conversions
+[[conv.ptr]], [[conv.mem]]. `sizeof(std::nullptr_t)` shall be equal to
+`sizeof(void*)`.
+A value of type `std::meta::info` is called a *reflection*. There exists
+a unique *null reflection*; every other reflection is a representation
+of
+- a value of scalar type [[temp.param]],
+- an object with static storage duration [[basic.stc]],
+- a variable [[basic.pre]],
+- a structured binding [[dcl.struct.bind]],
+- a function [[dcl.fct]],
+- a function parameter,
+- an enumerator [[dcl.enum]],
+- an annotation [[dcl.attr.grammar]],
+- a type alias [[dcl.typedef]],
+- a type [[basic.types]],
+- a class member [[class.mem]],
+- an unnamed bit-field [[class.bit]],
+- a class template [[temp.pre]],
+- a function template,
+- a variable template,
+- an alias template [[temp.alias]],
+- a concept [[temp.concept]],
+- a namespace alias [[namespace.alias]],
+- a namespace [[basic.namespace.general]],
+- a direct base class relationship [[class.derived.general]], or
+- a data member description [[class.mem.general]].
+A reflection is said to *represent* the corresponding construct.
+[*Note 12*: A reflection of a value can be produced by library
+functions such as `std::meta::constant_of` and
+`std::meta::reflect_constant`. — *end note*]
+[*Example 2*:
+``` cpp
+int arr[] = {1, 2, 3};
+auto [a1, a2, a3] = arr;
+[[=1]] void fn(int n);
+enum Enum { A };
+using Alias = int;
+struct B {};
+struct S : B {
+  int mem;
+  int : 0;
+};
+template<auto> struct TCls {};
+template<auto> void TFn();
+template<auto> int TVar;
+template<auto N> using TAlias = TCls<N>;
+template<auto> concept Concept = requires { true; };
+namespace NS {};
+namespace NSAlias = NS;
+constexpr auto ctx = std::meta::access_context::current();
+constexpr auto r1 = std::meta::reflect_constant(42);        // represents int value of 42
+constexpr auto r2 = std::meta::reflect_object(arr[1]);      // represents int object
+constexpr auto r3 = ^^arr;                                  // represents a variable
+constexpr auto r4 = ^^a3;                                   // represents a structured binding
+constexpr auto r5 = ^^fn;                                   // represents a function
+constexpr auto r6 = std::meta::parameters_of(^^fn)[0];      // represents a function parameter
+constexpr auto r7 = ^^Enum::A;                              // represents an enumerator
+constexpr auto r8 = std::meta::annotations_of(^^fn)[0];     // represents an annotation
+constexpr auto r9 = ^^Alias;                                // represents a type alias
+constexpr auto r10 = ^^S;                                   // represents a type
+constexpr auto r11 = ^^S::mem;                              // represents a class member
+constexpr auto r12 = std::meta::members_of(^^S, ctx)[1];    // represents an unnamed bit-field
+constexpr auto r13 = ^^TCls;                                // represents a class template
+constexpr auto r14 = ^^TFn;                                 // represents a function template
+constexpr auto r15 = ^^TVar;                                // represents a variable template
+constexpr auto r16 = ^^TAlias;                              // represents an alias template
+constexpr auto r17 = ^^Concept;                             // represents a concept
+constexpr auto r18 = ^^NSAlias;                             // represents a namespace alias
+constexpr auto r19 = ^^NS;                                  // represents a namespace
+constexpr auto r20 = std::meta::bases_of(^^S, ctx)[0];      // represents a direct base class relationship
+constexpr auto r21 =
+  std::meta::data_member_spec(^^int, {.name="member"});     // represents a data member description
+```
+— *end example*]
+*Recommended practice:* Implementations should not represent other
+constructs specified in this document, such as *using-declarator*s,
+partial template specializations, attributes, placeholder types,
+statements, or expressions, as values of type `std::meta::info`.
+[*Note 13*: Future revisions of this document can specify semantics for
+reflections representing any such constructs. — *end note*]
 The types described in this subclause are called *fundamental types*.
+[*Note 14*: Even if the implementation defines two or more fundamental
 types to have the same value representation, they are nevertheless
 different types. — *end note*]

Diff to HTML by rtfpessoa