[support.types] - C++17 → C++20

Files changed (1) hide show

tmp/tmpvmc1s4cc/{from.md → to.md} +50 -59

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

@@ -36,14 +36,14 @@ namespace std {
 ```
 The contents and meaning of the header `<cstddef>` are the same as the C
 standard library header `<stddef.h>`, except that it does not declare
 the type `wchar_t`, that it also declares the type `byte` and its
-associated operations ([[support.types.byteops]]), and as noted in
 [[support.types.nullptr]] and [[support.types.layout]].
-ISO C 7.19
 ### Header `<cstdlib>` synopsis <a id="cstdlib.syn">[[cstdlib.syn]]</a>
 ``` cpp
 namespace std {
@@ -141,14 +141,14 @@ standard library header `<stdlib.h>`, except that it does not declare
 the type `wchar_t`, and except as noted in [[support.types.nullptr]],
 [[support.types.layout]], [[support.start.term]], [[c.malloc]],
 [[c.mb.wcs]], [[alg.c.library]], [[c.math.rand]], and [[c.math.abs]].
 [*Note 1*: Several functions have additional overloads in this
-International Standard, but they have the same behavior as in the C
-standard library ([[library.c]]). — *end note*]
-ISO C 7.22
 ### Null pointers <a id="support.types.nullptr">[[support.types.nullptr]]</a>
 The type `nullptr_t` is a synonym for the type of a `nullptr`
 expression, and it has the characteristics described in
@@ -159,162 +159,153 @@ another `nullptr_t` object that is an lvalue can be
 taken. — *end note*]
 The macro `NULL` is an *implementation-defined* null pointer constant.
 [^1]
 ### Sizes, alignments, and offsets <a id="support.types.layout">[[support.types.layout]]</a>
 The macro `offsetof(type, member-designator)` has the same semantics as
 the corresponding macro in the C standard library header `<stddef.h>`,
-but accepts a restricted set of `type` arguments in this International
-Standard. Use of the `offsetof` macro with a `type` other than a
-standard-layout class (Clause  [[class]]) is
-conditionally-supported.[^2] The expression
-`offsetof(type, member-designator)` is never type-dependent (
-[[temp.dep.expr]]) and it is value-dependent ([[temp.dep.constexpr]])
-if and only if `type` is dependent. The result of applying the
-`offsetof` macro to a static data member or a function member is
-undefined. No operation invoked by the `offsetof` macro shall throw an
-exception and `noexcept(offsetof(type, member-designator))` shall be
-`true`.
 The type `ptrdiff_t` is an *implementation-defined* signed integer type
 that can hold the difference of two subscripts in an array object, as
 described in  [[expr.add]].
 The type `size_t` is an *implementation-defined* unsigned integer type
-that is large enough to contain the size in bytes of any object.
 [*Note 1*: It is recommended that implementations choose types for
-`ptrdiff_t` and `size_t` whose integer conversion ranks ([[conv.rank]])
 are no greater than that of `signed long int` unless a larger size is
 necessary to contain all the possible values. — *end note*]
-The type `max_align_t` is a POD type whose alignment requirement is at
-least as great as that of every scalar type, and whose alignment
-requirement is supported in every context.
-Alignment ([[basic.align]]), Sizeof ([[expr.sizeof]]), Additive
-operators ([[expr.add]]), Free store ([[class.free]]), and ISO C 7.19.
 ### `byte` type operations <a id="support.types.byteops">[[support.types.byteops]]</a>
 ``` cpp
 template<class IntType>
   constexpr byte& operator<<=(byte& b, IntType shift) noexcept;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_integral_v<IntType>` is `true`.
-*Effects:* Equivalent to:
-`return b = byte(static_cast<unsigned char>(b) << shift);`
 ``` cpp
 template<class IntType>
   constexpr byte operator<<(byte b, IntType shift) noexcept;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_integral_v<IntType>` is `true`.
 *Effects:* Equivalent to:
-`return byte(static_cast<unsigned char>(b) << shift);`
 ``` cpp
 template<class IntType>
   constexpr byte& operator>>=(byte& b, IntType shift) noexcept;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_integral_v<IntType>` is `true`.
-*Effects:* Equivalent to:
-`return b = byte(static_cast<unsigned char>(b) >> shift);`
 ``` cpp
 template<class IntType>
   constexpr byte operator>>(byte b, IntType shift) noexcept;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_integral_v<IntType>` is `true`.
 *Effects:* Equivalent to:
-`return byte(static_cast<unsigned char>(b) >> shift);`
 ``` cpp
 constexpr byte& operator|=(byte& l, byte r) noexcept;
 ```
-*Effects:* Equivalent to:
-``` cpp
-return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
-```
 ``` cpp
 constexpr byte operator|(byte l, byte r) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
 ```
 ``` cpp
 constexpr byte& operator&=(byte& l, byte r) noexcept;
 ```
-*Effects:* Equivalent to:
-``` cpp
-return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
-```
 ``` cpp
 constexpr byte operator&(byte l, byte r) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
 ```
 ``` cpp
 constexpr byte& operator^=(byte& l, byte r) noexcept;
 ```
-*Effects:* Equivalent to:
-``` cpp
-return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
-```
 ``` cpp
 constexpr byte operator^(byte l, byte r) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
 ```
 ``` cpp
 constexpr byte operator~(byte b) noexcept;
 ```
-*Effects:* Equivalent to: `return byte(s̃tatic_cast<unsigned char>(b));`
 ``` cpp
 template<class IntType>
   constexpr IntType to_integer(byte b) noexcept;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_integral_v<IntType>` is `true`.
-*Effects:* Equivalent to: `return IntType(b);`

 ```
 The contents and meaning of the header `<cstddef>` are the same as the C
 standard library header `<stddef.h>`, except that it does not declare
 the type `wchar_t`, that it also declares the type `byte` and its
+associated operations [[support.types.byteops]], and as noted in
 [[support.types.nullptr]] and [[support.types.layout]].
+See also: ISO C 7.19
 ### Header `<cstdlib>` synopsis <a id="cstdlib.syn">[[cstdlib.syn]]</a>
 ``` cpp
 namespace std {
 the type `wchar_t`, and except as noted in [[support.types.nullptr]],
 [[support.types.layout]], [[support.start.term]], [[c.malloc]],
 [[c.mb.wcs]], [[alg.c.library]], [[c.math.rand]], and [[c.math.abs]].
 [*Note 1*: Several functions have additional overloads in this
+document, but they have the same behavior as in the C standard library
+[[library.c]]. — *end note*]
+See also: ISO C 7.22
 ### Null pointers <a id="support.types.nullptr">[[support.types.nullptr]]</a>
 The type `nullptr_t` is a synonym for the type of a `nullptr`
 expression, and it has the characteristics described in
 taken. — *end note*]
 The macro `NULL` is an *implementation-defined* null pointer constant.
 [^1]
+See also: ISO C 7.19
 ### Sizes, alignments, and offsets <a id="support.types.layout">[[support.types.layout]]</a>
 The macro `offsetof(type, member-designator)` has the same semantics as
 the corresponding macro in the C standard library header `<stddef.h>`,
+but accepts a restricted set of `type` arguments in this document. Use
+of the `offsetof` macro with a `type` other than a standard-layout class
+[[class.prop]] is conditionally-supported.[^2] The expression
+`offsetof(type, member-designator)` is never type-dependent
+[[temp.dep.expr]] and it is value-dependent [[temp.dep.constexpr]] if
+and only if `type` is dependent. The result of applying the `offsetof`
+macro to a static data member or a function member is undefined. No
+operation invoked by the `offsetof` macro shall throw an exception and
+`noexcept(offsetof(type, member-designator))` shall be `true`.
 The type `ptrdiff_t` is an *implementation-defined* signed integer type
 that can hold the difference of two subscripts in an array object, as
 described in  [[expr.add]].
 The type `size_t` is an *implementation-defined* unsigned integer type
+that is large enough to contain the size in bytes of any object
+[[expr.sizeof]].
 [*Note 1*: It is recommended that implementations choose types for
+`ptrdiff_t` and `size_t` whose integer conversion ranks [[conv.rank]]
 are no greater than that of `signed long int` unless a larger size is
 necessary to contain all the possible values. — *end note*]
+The type `max_align_t` is a trivial standard-layout type whose alignment
+requirement is at least as great as that of every scalar type, and whose
+alignment requirement is supported in every context [[basic.align]].
+See also: ISO C 7.19
 ### `byte` type operations <a id="support.types.byteops">[[support.types.byteops]]</a>
 ``` cpp
 template<class IntType>
   constexpr byte& operator<<=(byte& b, IntType shift) noexcept;
 ```
+*Constraints:* `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to: `return b = b << shift;`
 ``` cpp
 template<class IntType>
   constexpr byte operator<<(byte b, IntType shift) noexcept;
 ```
+*Constraints:* `is_integral_v<IntType>` is `true`.
 *Effects:* Equivalent to:
+``` cpp
+return static_cast<byte>(static_cast<unsigned int>(b) << shift);
+```
 ``` cpp
 template<class IntType>
   constexpr byte& operator>>=(byte& b, IntType shift) noexcept;
 ```
+*Constraints:* `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to: `return b = b >> shift;`
 ``` cpp
 template<class IntType>
   constexpr byte operator>>(byte b, IntType shift) noexcept;
 ```
+*Constraints:* `is_integral_v<IntType>` is `true`.
 *Effects:* Equivalent to:
+``` cpp
+return static_cast<byte>(static_cast<unsigned int>(b) >> shift);
+```
 ``` cpp
 constexpr byte& operator|=(byte& l, byte r) noexcept;
 ```
+*Effects:* Equivalent to: `return l = l | r;`
 ``` cpp
 constexpr byte operator|(byte l, byte r) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return static_cast<byte>(static_cast<unsigned int>(l) | static_cast<unsigned int>(r));
 ```
 ``` cpp
 constexpr byte& operator&=(byte& l, byte r) noexcept;
 ```
+*Effects:* Equivalent to: `return l = l & r;`
 ``` cpp
 constexpr byte operator&(byte l, byte r) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return static_cast<byte>(static_cast<unsigned int>(l) & static_cast<unsigned int>(r));
 ```
 ``` cpp
 constexpr byte& operator^=(byte& l, byte r) noexcept;
 ```
+*Effects:* Equivalent to: `return l = l ^ r;`
 ``` cpp
 constexpr byte operator^(byte l, byte r) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return static_cast<byte>(static_cast<unsigned int>(l) ^ static_cast<unsigned int>(r));
 ```
 ``` cpp
 constexpr byte operator~(byte b) noexcept;
 ```
+*Effects:* Equivalent to:
+``` cpp
+return static_cast<byte>(~static_cast<unsigned int>(b));
+```
 ``` cpp
 template<class IntType>
   constexpr IntType to_integer(byte b) noexcept;
 ```
+*Constraints:* `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to: `return static_cast<IntType>(b);`

Diff to HTML by rtfpessoa