[format.string] - C++20 → C++23

Files changed (1) hide show

tmp/tmp5sxeuffy/{from.md → to.md} +140 -99

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

@@ -81,13 +81,13 @@ manual indexing. — *end note*]
 ``` cpp
 string s0 = format("{} to {}",   "a", "b"); // OK, automatic indexing
 string s1 = format("{1} to {0}", "a", "b"); // OK, manual indexing
 string s2 = format("{0} to {}",  "a", "b"); // not a format string (mixing automatic and manual indexing),
-                                            // throws format_error
 string s3 = format("{} to {1}",  "a", "b"); // not a format string (mixing automatic and manual indexing),
-                                            // throws format_error
 ```
 — *end example*]
 The *format-spec* field contains *format specifications* that define how
@@ -109,17 +109,17 @@ by *arg-id*, the string is not a format string for `args`.
 — *end example*]
 #### Standard format specifiers <a id="format.string.std">[[format.string.std]]</a>
-Each `formatter` specializations described in [[format.formatter.spec]]
 for fundamental and string types interprets *format-spec* as a
 *std-format-spec*.
 [*Note 1*: The format specification can be used to specify such details
-as field width, alignment, padding, and decimal precision. Some of the
-formatting options are only supported for arithmetic
 types. — *end note*]
 The syntax of format specifications is as follows:
 ``` bnf
@@ -159,21 +159,40 @@ precision
     '.' '{' arg-idₒₚₜ '}'
 ```
 ``` bnf
 type one of
-    'a A b B c d e E f F g G o p s x X'
 ```
-[*Note 2*: The *fill* character can be any character other than `{` or
-`}`. The presence of a fill character is signaled by the character
 following it, which must be one of the alignment options. If the second
 character of *std-format-spec* is not a valid alignment option, then it
-is assumed that both the fill character and the alignment option are
 absent. — *end note*]
-The *align* specifier applies to all argument types. The meaning of the
 various alignment options is as specified in [[format.align]].
 [*Example 1*:
 ``` cpp
@@ -183,34 +202,49 @@ string s1 = format("{:6}", 'x');        // value of s1 is "x\ \ \ \ \ "
 string s2 = format("{:*<6}", 'x');          // value of s2 is "x*****"
 string s3 = format("{:*>6}", 'x');          // value of s3 is "*****x"
 string s4 = format("{:*^6}", 'x');          // value of s4 is "**x***"
 string s5 = format("{:6d}", c);             // value of s5 is "\ \ \ 120"
 string s6 = format("{:6}", true);           // value of s6 is "true\ \ "
 ```
 — *end example*]
-[*Note 3*: Unless a minimum field width is defined, the field width is
-determined by the size of the content and the alignment option has no
-effect. — *end note*]
 **Table: Meaning of align options** <a id="format.align">[format.align]</a>
 | Option | Meaning                                                                                                                                                                                                                                                                                                      |
-| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `<`    | Forces the field to be aligned to the start of the available space. This is the default for non-arithmetic types, `charT`, and `bool`, unless an integer presentation type is specified. |
-| % `>`  | Forces the field to be aligned to the end of the available space. This is the default for arithmetic types other than `charT` and `bool` or when an integer presentation type is specified. |
-| % `^`  | Forces the field to be centered within the available space by inserting $\bigl\lfloor \frac{n}{2} \bigr\rfloor$ characters before and $\bigl\lceil \frac{n}{2} \bigr\rceil$ characters after the value, where $n$ is the total number of fill characters to insert. |
 The *sign* option is only valid for arithmetic types other than `charT`
 and `bool` or when an integer presentation type is specified. The
 meaning of the various options is as specified in [[format.sign]].
-[*Note 4*: For negative numbers and negative zero the output of
-`to_chars` will already contain the sign so no additional transformation
-is performed. — *end note*]
 The *sign* option applies to floating-point infinity and NaN.
 [*Example 2*:
@@ -236,88 +270,82 @@ form causes the result of the conversion of finite values to always
 contain a decimal-point character, even if no digits follow it.
 Normally, a decimal-point character appears in the result of these
 conversions only if a digit follows it. In addition, for `g` and `G`
 conversions, trailing zeros are not removed from the result.
-If `{ \opt{arg-id} }` is used in a *width* or *precision*, the value of
-the corresponding formatting argument is used in its place. If the
-corresponding formatting argument is not of integral type, or its value
-is negative for *precision* or non-positive for *width*, an exception of
-type `format_error` is thrown.
-The *positive-integer* in *width* is a decimal integer defining the
-minimum field width. If *width* is not specified, there is no minimum
-field width, and the field width is determined based on the content of
-the field.
-The *width* of a string is defined as the estimated number of column
-positions appropriate for displaying it in a terminal.
-[*Note 5*: This is similar to the semantics of the POSIX `wcswidth`
-function. — *end note*]
-For the purposes of width computation, a string is assumed to be in a
-locale-independent, implementation-defined encoding. Implementations
-should use a Unicode encoding on platforms capable of displaying Unicode
-text in a terminal.
-[*Note 6*: This is the case for Windows-based and many POSIX-based
-operating systems. — *end note*]
-For a string in a Unicode encoding, implementations should estimate the
-width of a string as the sum of estimated widths of the first code
-points in its extended grapheme clusters. The extended grapheme clusters
-of a string are defined by UAX \#29. The estimated width of the
-following code points is 2:
-- `U+1100-U+115F`
-- `U+2329-U+232A`
-- `U+2E80-U+303E`
-- `U+3040-U+A4CF`
-- `U+AC00-U+D7A3`
-- `U+F900-U+FAFF`
-- `U+FE10-U+FE19`
-- `U+FE30-U+FE6F`
-- `U+FF00-U+FF60`
-- `U+FFE0-U+FFE6`
-- `U+1F300-U+1F64F`
-- `U+1F900-U+1F9FF`
-- `U+20000-U+2FFFD`
-- `U+30000-U+3FFFD`
-The estimated width of other code points is 1.
-For a string in a non-Unicode encoding, the width of a string is
-unspecified.
-A zero (`0`) character preceding the *width* field pads the field with
-leading zeros (following any indication of sign or base) to the field
-width, except when applied to an infinity or NaN. This option is only
-valid for arithmetic types other than `charT` and `bool` or when an
-integer presentation type is specified. If the `0` character and an
-*align* option both appear, the `0` character is ignored.
 [*Example 3*:
 ``` cpp
 char c = 120;
 string s1 = format("{:+06d}", c);       // value of s1 is "+00120"
 string s2 = format("{:#06x}", 0xa);     // value of s2 is "0x000a"
-string s3 = format("{:<06}", -42);      // value of s3 is "-42\ \ \ " (0 is ignored because of < alignment)
 ```
 — *end example*]
-The *nonnegative-integer* in *precision* is a decimal integer defining
-the precision or maximum field size. It can only be used with
-floating-point and string types. For floating-point types this field
-specifies the formatting precision. For string types, this field
-provides an upper bound for the estimated width of the prefix of the
-input string that is copied into the output. For a string in a Unicode
-encoding, the formatter copies to the output the longest prefix of whole
-extended grapheme clusters whose estimated width is no greater than the
-precision.
 When the `L` option is used, the form used for the conversion is called
 the *locale-specific form*. The `L` option is only valid for arithmetic
 types, and its effect depends upon the type.
@@ -338,22 +366,23 @@ The available string presentation types are specified in
 [[format.type.string]].
 **Table: Meaning of type options for strings** <a id="format.type.string">[format.type.string]</a>
 | Type      | Meaning                                                            |
-| --------- | -------------------------------- |
 | none, `s` | Copies the string to the output.                                   |
 The meaning of some non-string presentation types is defined in terms of
 a call to `to_chars`. In such cases, let \[`first`, `last`) be a range
 large enough to hold the `to_chars` output and `value` be the formatting
 argument value. Formatting is done as if by calling `to_chars` as
 specified and copying the output through the output iterator of the
 format context.
-[*Note 7*: Additional padding and adjustments are performed prior to
 copying the output through the output iterator as specified by the
 format specifiers. — *end note*]
 The available integer presentation types for integral types other than
 `bool` and `charT` are specified in [[format.type.int]].
@@ -362,49 +391,61 @@ The available integer presentation types for integral types other than
 ``` cpp
 string s0 = format("{}", 42);                           // value of s0 is "42"
 string s1 = format("{0:b} {0:d} {0:o} {0:x}", 42);      // value of s1 is "101010 42 52 2a"
 string s2 = format("{0:#x} {0:#X}", 42);                // value of s2 is "0x2a 0X2A"
-string s3 = format("{:L}", 1234);                       // value of s3 might be "1,234"
                                                         // (depending on the locale)
 ```
 — *end example*]
-[*Note 8*: If the formatting argument type is `charT` or `bool`, the
-default is instead `c` or `s`, respectively. — *end note*]
 The available `charT` presentation types are specified in
 [[format.type.char]].
 **Table: Meaning of type options for `charT`** <a id="format.type.char">[format.type.char]</a>
 | Type                           | Meaning                                                               |
-| ------------------------------ | ------------------------------------ |
 | none, `c`                      | Copies the character to the output.                                   |
 | % `b`, `B`, `d`, `o`, `x`, `X` | As specified in [[format.type.int]].                                  |
 The available `bool` presentation types are specified in
 [[format.type.bool]].
 **Table: Meaning of type options for `bool`** <a id="format.type.bool">[format.type.bool]</a>
 | Type                           | Meaning                                                                                |
-| ----------------------------------- | -------------------------------------------------------------------------------------- |
 | none, `s`                      | Copies textual representation, either `true` or `false`, to the output.                |
-| % `b`, `B`, `c`, `d`, `o`, `x`, `X` | As specified in [[format.type.int]] for the value `static_cast<unsigned char>(value)`. |
 The available floating-point presentation types and their meanings for
 values other than infinity and NaN are specified in
 [[format.type.float]]. For lower-case presentation types, infinity and
 NaN are formatted as `inf` and `nan`, respectively. For upper-case
 presentation types, infinity and NaN are formatted as `INF` and `NAN`,
 respectively.
-[*Note 9*: In either case, a sign is included if indicated by the
 *sign* option. — *end note*]
 **Table: Meaning of type options for floating-point types** <a id="format.type.float">[format.type.float]</a>
 | Type       | Meaning                                                                                                                                                                                                                                                                                                   |
@@ -420,15 +461,15 @@ respectively.
 The available pointer presentation types and their mapping to `to_chars`
 are specified in [[format.type.ptr]].
-[*Note 10*: Pointer presentation types also apply to
 `nullptr_t`. — *end note*]
 **Table: Meaning of type options for pointer types** <a id="format.type.ptr">[format.type.ptr]</a>
 | Type      | Meaning                                                                                                                                                                                                                                  |
-| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| none, `p` | If `uintptr_t` is defined, \begin{codeblock} to_chars(first, last, reinterpret_cast<uintptr_t>(value), 16) \end{codeblock} with the prefix `0x` added to the output; otherwise, implementation-defined. |

 ``` cpp
 string s0 = format("{} to {}",   "a", "b"); // OK, automatic indexing
 string s1 = format("{1} to {0}", "a", "b"); // OK, manual indexing
 string s2 = format("{0} to {}",  "a", "b"); // not a format string (mixing automatic and manual indexing),
+                                            // ill-formed
 string s3 = format("{} to {1}",  "a", "b"); // not a format string (mixing automatic and manual indexing),
+                                            // ill-formed
 ```
 — *end example*]
 The *format-spec* field contains *format specifications* that define how
 — *end example*]
 #### Standard format specifiers <a id="format.string.std">[[format.string.std]]</a>
+Each `formatter` specialization described in [[format.formatter.spec]]
 for fundamental and string types interprets *format-spec* as a
 *std-format-spec*.
 [*Note 1*: The format specification can be used to specify such details
+as minimum field width, alignment, padding, and decimal precision. Some
+of the formatting options are only supported for arithmetic
 types. — *end note*]
 The syntax of format specifications is as follows:
 ``` bnf
     '.' '{' arg-idₒₚₜ '}'
 ```
 ``` bnf
 type one of
+    'a A b B c d e E f F g G o p s x X ?'
 ```
+Field widths are specified in *field width units*; the number of column
+positions required to display a sequence of characters in a terminal.
+The *minimum field width* is the number of field width units a
+replacement field minimally requires of the formatted sequence of
+characters produced for a format argument. The *estimated field width*
+is the number of field width units that are required for the formatted
+sequence of characters produced for a format argument independent of the
+effects of the *width* option. The *padding width* is the greater of `0`
+and the difference of the minimum field width and the estimated field
+width.
+[*Note 2*: The POSIX `wcswidth` function is an example of a function
+that, given a string, returns the number of column positions required by
+a terminal to display the string. — *end note*]
+The *fill character* is the character denoted by the *fill* option or,
+if the *fill* option is absent, the space character. For a format
+specification in UTF-8, UTF-16, or UTF-32, the fill character
+corresponds to a single Unicode scalar value.
+[*Note 3*: The presence of a *fill* option is signaled by the character
 following it, which must be one of the alignment options. If the second
 character of *std-format-spec* is not a valid alignment option, then it
+is assumed that the *fill* and *align* options are both
 absent. — *end note*]
+The *align* option applies to all argument types. The meaning of the
 various alignment options is as specified in [[format.align]].
 [*Example 1*:
 ``` cpp
 string s2 = format("{:*<6}", 'x');          // value of s2 is "x*****"
 string s3 = format("{:*>6}", 'x');          // value of s3 is "*****x"
 string s4 = format("{:*^6}", 'x');          // value of s4 is "**x***"
 string s5 = format("{:6d}", c);             // value of s5 is "\ \ \ 120"
 string s6 = format("{:6}", true);           // value of s6 is "true\ \ "
+string s7 = format("{:*<6.3}", "123456");   // value of s7 is "123***"
+string s8 = format("{:02}", 1234);          // value of s8 is "1234"
+string s9 = format("{:*<}", "12");          // value of s9 is "12"
+string sA = format("{:*<6}", "12345678");   // value of sA is "12345678"
 ```
 — *end example*]
+[*Note 4*: The *fill*, *align*, and `0` options have no effect when the
+minimum field width is not greater than the estimated field width
+because padding width is `0` in that case. Since fill characters are
+assumed to have a field width of `1`, use of a character with a
+different field width can produce misaligned output. The
+U+1f921 (clown face) character has a field width of `2`. The examples
+above that include that character illustrate the effect of the field
+width when that character is used as a fill character as opposed to when
+it is used as a formatting argument. — *end note*]
 **Table: Meaning of align options** <a id="format.align">[format.align]</a>
 | Option | Meaning                                                                                                                                                                                                                                                                                                      |
+| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `<`    | Forces the formatted argument to be aligned to the start of the field by inserting $n$ fill characters after the formatted argument where $n$ is the padding width. This is the default for non-arithmetic non-pointer types, `charT`, and `bool`, unless an integer presentation type is specified. |
+| % `>`  | Forces the formatted argument to be aligned to the end of the field by inserting $n$ fill characters before the formatted argument where $n$ is the padding width. This is the default for arithmetic types other than `charT` and `bool`, pointer types, or when an integer presentation type is specified. |
+| % `^`  | Forces the formatted argument to be centered within the field by inserting $\bigl\lfloor \frac{n}{2} \bigr\rfloor$ fill characters before and $\bigl\lceil \frac{n}{2} \bigr\rceil$ fill characters after the formatted argument, where $n$ is the padding width. |
 The *sign* option is only valid for arithmetic types other than `charT`
 and `bool` or when an integer presentation type is specified. The
 meaning of the various options is as specified in [[format.sign]].
+**Table: Meaning of sign options** <a id="format.sign">[format.sign]</a>
+| Option  | Meaning                                                                                                                                                                                                                                                                                                                                    |
+| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `+`     | Indicates that a sign should be used for both non-negative and negative numbers. The `+` sign is inserted before the output of `to_chars` for non-negative numbers other than negative zero. *For negative numbers and negative zero the output of `to_chars` will already contain the sign so no additional transformation is performed.* |
+| % `-`   | Indicates that a sign should be used for negative numbers and negative zero only (this is the default behavior).                                                                                                                                                                                                                           |
+| % space | Indicates that a leading space should be used for non-negative numbers other than negative zero, and a minus sign for negative numbers and negative zero.                                                                                                                                                                                  |
 The *sign* option applies to floating-point infinity and NaN.
 [*Example 2*:
 contain a decimal-point character, even if no digits follow it.
 Normally, a decimal-point character appears in the result of these
 conversions only if a digit follows it. In addition, for `g` and `G`
 conversions, trailing zeros are not removed from the result.
+The `0` option is valid for arithmetic types other than `charT` and
+`bool` or when an integer presentation type is specified. For formatting
+arguments that have a value other than an infinity or a NaN, this option
+pads the formatted argument by inserting the `0` character n times
+following the sign or base prefix indicators (if any) where n is `0` if
+the *align* option is present and is the padding width otherwise.
 [*Example 3*:
 ``` cpp
 char c = 120;
 string s1 = format("{:+06d}", c);       // value of s1 is "+00120"
 string s2 = format("{:#06x}", 0xa);     // value of s2 is "0x000a"
+string s3 = format("{:<06}", -42);      // value of s3 is "-42\ \ \ " (0 has no effect)
+string s4 = format("{:06}", inf);       // value of s4 is "\ \ \ inf" (0 has no effect)
 ```
 — *end example*]
+The *width* option specifies the minimum field width. If the *width*
+option is absent, the minimum field width is `0`.
+If `{ \opt{arg-id} }` is used in a *width* or *precision* option, the
+value of the corresponding formatting argument is used as the value of
+the option. If the corresponding formatting argument is not of standard
+signed or unsigned integer type, or its value is negative, an exception
+of type `format_error` is thrown.
+If *positive-integer* is used in a *width* option, the value of the
+*positive-integer* is interpreted as a decimal integer and used as the
+value of the option.
+For the purposes of width computation, a string is assumed to be in a
+locale-independent, *implementation-defined* encoding. Implementations
+should use either UTF-8, UTF-16, or UTF-32, on platforms capable of
+displaying Unicode text in a terminal.
+[*Note 5*:
+This is the case for Windows[^2]
+-based and many POSIX-based operating systems.
+— *end note*]
+For a sequence of characters in UTF-8, UTF-16, or UTF-32, an
+implementation should use as its field width the sum of the field widths
+of the first code point of each extended grapheme cluster. Extended
+grapheme clusters are defined by UAX \#29 of the Unicode Standard. The
+following code points have a field width of 2:
+- any code point with the `East_Asian_Width="W"` or
+  `East_Asian_Width="F"` Derived Extracted Property as described by UAX
+  \#44 of the Unicode Standard
+- `U+4dc0` – `U+4dff` (Yijing Hexagram Symbols)
+- `U+1f300` – `U+1f5ff` (Miscellaneous Symbols and Pictographs)
+- `U+1f900` – `U+1f9ff` (Supplemental Symbols and Pictographs)
+The field width of all other code points is 1.
+For a sequence of characters in neither UTF-8, UTF-16, nor UTF-32, the
+field width is unspecified.
+The *precision* option is valid for floating-point and string types. For
+floating-point types, the value of this option specifies the precision
+to be used for the floating-point presentation type. For string types,
+this option specifies the longest prefix of the formatted argument to be
+included in the replacement field such that the field width of the
+prefix is no greater than the value of this option.
+If *nonnegative-integer* is used in a *precision* option, the value of
+the decimal integer is used as the value of the option.
 When the `L` option is used, the form used for the conversion is called
 the *locale-specific form*. The `L` option is only valid for arithmetic
 types, and its effect depends upon the type.
 [[format.type.string]].
 **Table: Meaning of type options for strings** <a id="format.type.string">[format.type.string]</a>
 | Type      | Meaning                                                            |
+| --------- | ------------------------------------------------------------------ |
 | none, `s` | Copies the string to the output.                                   |
+| % `?`     | Copies the escaped string [[format.string.escaped]] to the output. |
 The meaning of some non-string presentation types is defined in terms of
 a call to `to_chars`. In such cases, let \[`first`, `last`) be a range
 large enough to hold the `to_chars` output and `value` be the formatting
 argument value. Formatting is done as if by calling `to_chars` as
 specified and copying the output through the output iterator of the
 format context.
+[*Note 6*: Additional padding and adjustments are performed prior to
 copying the output through the output iterator as specified by the
 format specifiers. — *end note*]
 The available integer presentation types for integral types other than
 `bool` and `charT` are specified in [[format.type.int]].
 ``` cpp
 string s0 = format("{}", 42);                           // value of s0 is "42"
 string s1 = format("{0:b} {0:d} {0:o} {0:x}", 42);      // value of s1 is "101010 42 52 2a"
 string s2 = format("{0:#x} {0:#X}", 42);                // value of s2 is "0x2a 0X2A"
+string s3 = format("{:L}", 1234);                       // value of s3 can be "1,234"
                                                         // (depending on the locale)
 ```
 — *end example*]
+**Table: Meaning of type options for integer types** <a id="format.type.int">[format.type.int]</a>
+| Type   | Meaning                                                                                                                                                   |
+| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `b`    | `to_chars(first, last, value, 2)`; \indextext{base prefix}% the base prefix is `0b`.                                                                      |
+| % `B`  | The same as `b`, except that \indextext{base prefix}% the base prefix is `0B`.                                                                            |
+| % `c`  | Copies the character `static_cast<charT>(value)` to the output. Throws `format_error` if `value` is not in the range of representable values for `charT`. |
+| % `d`  | `to_chars(first, last, value)`.                                                                                                                           |
+| % `o`  | `to_chars(first, last, value, 8)`; \indextext{base prefix}% the base prefix is `0` if `value` is nonzero and is empty otherwise.                          |
+| % `x`  | `to_chars(first, last, value, 16)`; \indextext{base prefix}% the base prefix is `0x`.                                                                     |
+| % `X`  | The same as `x`, except that it uses uppercase letters for digits above 9 and \indextext{base prefix}% the base prefix is `0X`.                           |
+| % none | The same as `d`. *If the formatting argument type is `charT` or `bool`, the default is instead `c` or `s`, respectively.*                                 |
 The available `charT` presentation types are specified in
 [[format.type.char]].
 **Table: Meaning of type options for `charT`** <a id="format.type.char">[format.type.char]</a>
 | Type                           | Meaning                                                               |
+| ------------------------------ | --------------------------------------------------------------------- |
 | none, `c`                      | Copies the character to the output.                                   |
 | % `b`, `B`, `d`, `o`, `x`, `X` | As specified in [[format.type.int]].                                  |
+| % `?`                          | Copies the escaped character [[format.string.escaped]] to the output. |
 The available `bool` presentation types are specified in
 [[format.type.bool]].
 **Table: Meaning of type options for `bool`** <a id="format.type.bool">[format.type.bool]</a>
 | Type                           | Meaning                                                                                |
+| ------------------------------ | -------------------------------------------------------------------------------------- |
 | none, `s`                      | Copies textual representation, either `true` or `false`, to the output.                |
+| % `b`, `B`, `d`, `o`, `x`, `X` | As specified in [[format.type.int]] for the value `static_cast<unsigned char>(value)`. |
 The available floating-point presentation types and their meanings for
 values other than infinity and NaN are specified in
 [[format.type.float]]. For lower-case presentation types, infinity and
 NaN are formatted as `inf` and `nan`, respectively. For upper-case
 presentation types, infinity and NaN are formatted as `INF` and `NAN`,
 respectively.
+[*Note 7*: In either case, a sign is included if indicated by the
 *sign* option. — *end note*]
 **Table: Meaning of type options for floating-point types** <a id="format.type.float">[format.type.float]</a>
 | Type       | Meaning                                                                                                                                                                                                                                                                                                   |
 The available pointer presentation types and their mapping to `to_chars`
 are specified in [[format.type.ptr]].
+[*Note 8*: Pointer presentation types also apply to
 `nullptr_t`. — *end note*]
 **Table: Meaning of type options for pointer types** <a id="format.type.ptr">[format.type.ptr]</a>
 | Type      | Meaning                                                                                                                                                                                                                                  |
+| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| none, `p` | If `uintptr_t` is defined, \begin{codeblock} to_chars(first, last, reinterpret_cast<uintptr_t>(value), 16) \end{codeblock} with the prefix `0x` inserted immediately before the output of `to_chars`; otherwise, implementation-defined. |

Diff to HTML by rtfpessoa