UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, FLOAT, DOUBLE

蔚落 2023-06-22 13:59 14阅读 0赞

UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64

固定长度的整型，包括有符号整型或无符号整型。

## 整型范围[¶][Link 1] ##

*  Int8 - \[-128 : 127\]
 *  Int16 - \[-32768 : 32767\]
 *  Int32 - \[-2147483648 : 2147483647\]
 *  Int64 - \[-9223372036854775808 : 9223372036854775807\]

## 无符号整型范围[¶][Link 2] ##

*  UInt8 - \[0 : 255\]
 *  UInt16 - \[0 : 65535\]
 *  UInt32 - \[0 : 4294967295\]
 *  UInt64 - \[0 : 18446744073709551615\]

## FLOAT/DOUBLE ##

一般来说，float是32位，double是64位，其极限值在C++标准库文件<float.h>中有定义，摘录下来其中一段如下，

#define DBL_EPSILON      2.2204460492503131e-016 // smallest such that 1.0+DBL_EPSILON != 1.0
    #define DBL_MAX          1.7976931348623158e+308 // max value
    #define DBL_MAX_10_EXP   308                     // max decimal exponent
    #define DBL_MAX_EXP      1024                    // max binary exponent
    #define DBL_MIN          2.2250738585072014e-308 // min positive value
    #define DBL_MIN_10_EXP   (-307)                  // min decimal exponent
    #define DBL_MIN_EXP      (-1021)                 // min binary exponent
    #define DBL_TRUE_MIN     4.9406564584124654e-324 // min positive value
    
    #define FLT_EPSILON      1.192092896e-07F        // smallest such that 1.0+FLT_EPSILON != 1.0
    #define FLT_MAX          3.402823466e+38F        // max value
    #define FLT_MAX_10_EXP   38                      // max decimal exponent
    #define FLT_MAX_EXP      128                     // max binary exponent
    #define FLT_MIN          1.175494351e-38F        // min normalized positive value
    #define FLT_MIN_10_EXP   (-37)                   // min decimal exponent
    #define FLT_MIN_EXP      (-125)                  // min binary exponent
    #define FLT_TRUE_MIN     1.401298464e-45F        // min positive value

## 微软的说明与对应的char, short, int, long long ##

Microsoft C/C++ features support for sized integer types. You can declare 8-, 16-, 32-, or 64-bit integer variables by using the **\_\_int***n* type specifier, where *n* is 8, 16, 32, or 64.

The following example declares one variable for each of these types of sized integers:

C++Copy

__int8 nSmall;      // Declares 8-bit integer
    __int16 nMedium;    // Declares 16-bit integer
    __int32 nLarge;     // Declares 32-bit integer
    __int64 nHuge;      // Declares 64-bit integer

The types **\_\_int8**, **\_\_int16**, and **\_\_int32** are synonyms for the ANSI types that have the same size, and are useful for writing portable code that behaves identically across multiple platforms. The **\_\_int8** data type is synonymous with type **char**, **\_\_int16** is synonymous with type **short**, and **\_\_int32** is synonymous with type **int**. The **\_\_int64** type is synonymous with type **long long**.

For compatibility with previous versions, **\_int8**, **\_int16**, **\_int32**, and **\_int64** are synonyms for **\_\_int8**, **\_\_int16**, **\_\_int32**, and **\_\_int64** unless compiler option [/Za (Disable language extensions)][Za _Disable language extensions] is specified.

## printf格式化输出[¶][Link 2] ##

比如UINT64,

#include <stdio.h>
 #include <stdint.h>
 int64_t my_int = 999999999999999999;
 printf("This is my_int: %I64d\n", my_int);

## 微软对格式化输出的解释: ##

原文地址：

[https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=vs-2019][https_docs.microsoft.com_en-us_cpp_c-runtime-library_format-specification-syntax-printf-and-wprintf-functions_view_vs-2019]

# Format specification syntax: printf and wprintf functions #

The various `printf` and `wprintf` functions take a format string and optional arguments and produce a formatted sequence of characters for output. The format string contains zero or more *directives*, which are either literal characters for output or encoded *conversion specifications* that describe how to format an argument in the output. This article describes the syntax used to encode conversion specifications in the format string. For a listing of these functions, see [Stream I/O][Stream I_O].

A conversion specification consists of optional and required fields in this form:

**%**\[[*flags*][flags]\]\[[*width*][width]\]\[.[*precision*][precision]\]\[[*size*][size]\][*type*][type]

Each field of the conversion specification is a character or a number that signifies a particular format option or conversion specifier. The required *type* field specifies the kind of conversion to be applied to an argument. The optional *flags*, *width*, and *precision* fields control additional format aspects such as leading spaces or zeroes, justification, and displayed precision. The *size* field specifies the size of the argument consumed and converted.

A basic conversion specification contains only the percent sign and a *type* character. For example, `%s` specifies a string conversion. To print a percent-sign character, use `%%`. If a percent sign is followed by a character that has no meaning as a format field, the invalid parameter handler is invoked. For more information, see [Parameter Validation][].

Important

For security and stability, ensure that conversion specification strings are not user-defined. For example, consider a program that prompts the user to enter a name and stores the input in a string variable that's named `user_name`. To print `user_name`, do not do this:

`printf( user_name ); /* Danger! If user_name contains "%s", program will crash */`

Instead, do this:

`printf( "%s", user_name );`

Note

In Visual Studio 2015 The `printf` and `scanf` family of functions were declared as **inline** and moved to the `<stdio.h>` and `<conio.h>` headers. If you are migrating older code you might see *LNK2019* in connection with these functions. For more information, see [Visual C++ change history 2003 - 2015][Visual C_ change history 2003 - 2015].

## Type conversion specifier ##

The *type* conversion specifier character specifies whether to interpret the corresponding argument as a character, a string, a pointer, an integer, or a floating-point number. The *type* character is the only required conversion specification field, and it appears after any optional fields.

The arguments that follow the format string are interpreted according to the corresponding *type* character and the optional [size][] prefix. Conversions for character types `char` and `wchar_t` are specified by using **c** or **C**, and single-byte and multi-byte or wide character strings are specified by using **s** or **S**, depending on which formatting function is being used. Character and string arguments that are specified by using **c** and **s** are interpreted as `char` and `char*` by `printf` family functions, or as `wchar_t` and `wchar_t*` by `wprintf` family functions. Character and string arguments that are specified by using **C** and **S** are interpreted as `wchar_t` and `wchar_t*` by `printf` family functions, or as `char` and `char*` by `wprintf` family functions. This behavior is Microsoft-specific.

Integer types such as `short`, `int`, `long`, `long long`, and their `unsigned` variants, are specified by using **d**, **i**, **o**, **u**, **x**, and **X**. Floating-point types such as `float`, `double`, and `long double`, are specified by using **a**, **A**, **e**, **E**, **f**, **F**, **g**, and **G**. By default, unless they are modified by a *size* prefix, integer arguments are coerced to `int` type, and floating-point arguments are coerced to `double`. On 64-bit systems, an `int` is a 32-bit value; therefore, 64-bit integers will be truncated when they are formatted for output unless a *size* prefix of **ll** or **I64** is used. Pointer types that are specified by **p** use the default pointer size for the platform.

Note

**Microsoft-specific:** The **Z** type character, and the behavior of the **c**, **C**, **s**, and **S** type characters when they are used with the `printf` and `wprintf` functions, are Microsoft extensions. The ISO C standard uses **c** and **s** consistently for narrow characters and strings, and **C** and **S** for wide characters and strings, in all formatting functions.

### Type field characters ###

<table> 
 <thead> 
 <tr> 
 <th>Type character</th> 
 <th>Argument</th> 
 <th>Output format</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>c</td> 
 <td>Character</td> 
 <td>When used with&nbsp;<code>printf</code>&nbsp;functions, specifies a single-byte character; when used with&nbsp;<code>wprintf</code>&nbsp;functions, specifies a wide character.</td> 
 </tr> 
 <tr> 
 <td>C</td> 
 <td>Character</td> 
 <td>When used with&nbsp;<code>printf</code>&nbsp;functions, specifies a wide character; when used with&nbsp;<code>wprintf</code>&nbsp;functions, specifies a single-byte character.</td> 
 </tr> 
 <tr> 
 <td>d</td> 
 <td>Integer</td> 
 <td>Signed decimal integer.</td> 
 </tr> 
 <tr> 
 <td>i</td> 
 <td>Integer</td> 
 <td>Signed decimal integer.</td> 
 </tr> 
 <tr> 
 <td>o</td> 
 <td>Integer</td> 
 <td>Unsigned octal integer.</td> 
 </tr> 
 <tr> 
 <td>u</td> 
 <td>Integer</td> 
 <td>Unsigned decimal integer.</td> 
 </tr> 
 <tr> 
 <td>x</td> 
 <td>Integer</td> 
 <td>Unsigned hexadecimal integer; uses "abcdef."</td> 
 </tr> 
 <tr> 
 <td>X</td> 
 <td>Integer</td> 
 <td>Unsigned hexadecimal integer; uses "ABCDEF."</td> 
 </tr> 
 <tr> 
 <td>e</td> 
 <td>Floating-point</td> 
 <td>Signed value that has the form [-]d.dddde±dd[d], where&nbsp;d&nbsp;is one decimal digit,&nbsp;dddd&nbsp;is one or more decimal digits depending on the specified precision, or six by default, and&nbsp;dd[d] is two or three decimal digits depending on the&nbsp;<a href="https://docs.microsoft.com/en-us/cpp/c-runtime-library/set-output-format?view=vs-2019" rel="nofollow">output format</a>&nbsp;and size of the exponent.</td> 
 </tr> 
 <tr> 
 <td>E</td> 
 <td>Floating-point</td> 
 <td>Identical to the&nbsp;e&nbsp;format except that&nbsp;E&nbsp;rather than&nbsp;e&nbsp;introduces the exponent.</td> 
 </tr> 
 <tr> 
 <td>f</td> 
 <td>Floating-point</td> 
 <td>Signed value that has the form [-]dddd.dddd, where&nbsp;dddd&nbsp;is one or more decimal digits. The number of digits before the decimal point depends on the magnitude of the number, and the number of digits after the decimal point depends on the requested precision, or six by default.</td> 
 </tr> 
 <tr> 
 <td>F</td> 
 <td>Floating-point</td> 
 <td>Identical to the&nbsp;f&nbsp;format except that infinity and nan output is capitalized.</td> 
 </tr> 
 <tr> 
 <td>g</td> 
 <td>Floating-point</td> 
 <td>Signed values are displayed in&nbsp;f&nbsp;or&nbsp;e&nbsp;format, whichever is more compact for the given value and precision. The&nbsp;e&nbsp;format is used only when the exponent of the value is less than -4 or greater than or equal to the&nbsp;precision&nbsp;argument. Trailing zeros are truncated, and the decimal point appears only if one or more digits follow it.</td> 
 </tr> 
 <tr> 
 <td>G</td> 
 <td>Floating-point</td> 
 <td>Identical to the&nbsp;g&nbsp;format, except that&nbsp;E, rather than&nbsp;e, introduces the exponent (where appropriate).</td> 
 </tr> 
 <tr> 
 <td>a</td> 
 <td>Floating-point</td> 
 <td>Signed hexadecimal double-precision floating-point value that has the form [-]0xh.hhhhp±dd, where&nbsp;h.hhhh&nbsp;are the hex digits (using lower case letters) of the mantissa, and&nbsp;dd&nbsp;are one or more digits for the exponent. The precision specifies the number of digits after the point.</td> 
 </tr> 
 <tr> 
 <td>A</td> 
 <td>Floating-point</td> 
 <td>Signed hexadecimal double-precision floating-point value that has the form [-]0Xh.hhhhP±dd, where&nbsp;h.hhhh&nbsp;are the hex digits (using capital letters) of the mantissa, and&nbsp;dd&nbsp;are one or more digits for the exponent. The precision specifies the number of digits after the point.</td> 
 </tr> 
 <tr> 
 <td>n</td> 
 <td>Pointer to integer</td> 
 <td>Number of characters that are successfully written so far to the stream or buffer. This value is stored in the integer whose address is given as the argument. The size of the integer pointed at can be controlled by an argument size specification prefix. The&nbsp;n&nbsp;specifier is disabled by default; for information see the important security note.</td> 
 </tr> 
 <tr> 
 <td>p</td> 
 <td>Pointer type</td> 
 <td>Displays the argument as an address in hexadecimal digits.</td> 
 </tr> 
 <tr> 
 <td>s</td> 
 <td>String</td> 
 <td>When used with&nbsp;<code>printf</code>&nbsp;functions, specifies a single-byte or multi-byte character string; when used with&nbsp;<code>wprintf</code>&nbsp;functions, specifies a wide-character string. Characters are displayed up to the first null character or until the&nbsp;precision&nbsp;value is reached.</td> 
 </tr> 
 <tr> 
 <td>S</td> 
 <td>String</td> 
 <td>When used with&nbsp;<code>printf</code>&nbsp;functions, specifies a wide-character string; when used with&nbsp;<code>wprintf</code>&nbsp;functions, specifies a single-byte or multi-byte character string. Characters are displayed up to the first null character or until the&nbsp;precision&nbsp;value is reached.</td> 
 </tr> 
 <tr> 
 <td>Z</td> 
 <td><code>ANSI_STRING</code>&nbsp;or&nbsp;<code>UNICODE_STRING</code>&nbsp;structure</td> 
 <td>When the address of an&nbsp;<a href="https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-string" rel="nofollow">ANSI_STRING</a>&nbsp;or&nbsp;<a href="https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-_unicode_string" rel="nofollow">UNICODE_STRING</a>&nbsp;structure is passed as the argument, displays the string contained in the buffer pointed to by the&nbsp;<code>Buffer</code>&nbsp;field of the structure. Use a&nbsp;size&nbsp;modifier prefix of&nbsp;w&nbsp;to specify a&nbsp;<code>UNICODE_STRING</code>&nbsp;argument—for example,&nbsp;<code>%wZ</code>. The&nbsp;<code>Length</code>&nbsp;field of the structure must be set to the length, in bytes, of the string. The&nbsp;<code>MaximumLength</code>&nbsp;field of the structure must be set to the length, in bytes, of the buffer. Typically, the&nbsp;Z&nbsp;type character is used only in driver debugging functions that use a conversion specification, such as&nbsp;<code>dbgPrint</code>&nbsp;and&nbsp;<code>kdPrint</code>.</td> 
 </tr> 
 </tbody> 
</table>

Starting in Visual Studio 2015, if the argument that corresponds to a floating-point conversion specifier (**a**, **A**, **e**, **E**, **f**, **F**, **g**, **G**) is infinite, indefinite, or NaN, the formatted output conforms to the C99 standard. This table lists the formatted output:

<table> 
 <thead> 
 <tr> 
 <th>Value</th> 
 <th>Output</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>infinity</td> 
 <td><code>inf</code></td> 
 </tr> 
 <tr> 
 <td>Quiet NaN</td> 
 <td><code>nan</code></td> 
 </tr> 
 <tr> 
 <td>Signaling NaN</td> 
 <td><code>nan(snan)</code></td> 
 </tr> 
 <tr> 
 <td>Indefinite NaN</td> 
 <td><code>nan(ind)</code></td> 
 </tr> 
 </tbody> 
</table>

Any of these values may be prefixed by a sign. If a floating-point *type* conversion specifier character is a capital letter, then the output is also formatted in capital letters. For example, if the format specifier is `%F` instead of `%f`, an infinity is formatted as `INF` instead of `inf`. The `scanf` functions can also parse these strings, so these values can make a round trip through `printf` and `scanf` functions.

Before Visual Studio 2015, the CRT used a different, non-standard format for output of infinite, indefinite, and NaN values:

<table> 
 <thead> 
 <tr> 
 <th>Value</th> 
 <th>Output</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>+ infinity</td> 
 <td><code>1.#INF</code>&nbsp;random-digits</td> 
 </tr> 
 <tr> 
 <td>- infinity</td> 
 <td><code>-1.#INF</code>&nbsp;random-digits</td> 
 </tr> 
 <tr> 
 <td>Indefinite (same as quiet NaN)</td> 
 <td>digit&nbsp;<code>.#IND</code>&nbsp;random-digits</td> 
 </tr> 
 <tr> 
 <td>NaN</td> 
 <td>digit&nbsp;<code>.#NAN</code>&nbsp;random-digits</td> 
 </tr> 
 </tbody> 
</table>

Any of these may have been prefixed by a sign, and may have been formatted slightly differently depending on field width and precision, sometimes with unusual effects. For example, `printf("%.2f\n", INFINITY)` would print `1.#J` because the \#INF would be "rounded" to 2 digits of precision.

Note

If the argument that corresponds to `%s` or `%S`, or the `Buffer` field of the argument that corresponds to `%Z`, is a null pointer, "(null)" is displayed.

Note

In all exponential formats, the minimum number of digits of exponent to display is two, using three only if necessary. By using the [\_set\_output\_format][set_output_format] function, you can set the number of digits displayed to three for backward compatibility with code written for Visual Studio 2013 and before.

Important

Because the `%n` format is inherently insecure, it is disabled by default. If `%n` is encountered in a format string, the invalid parameter handler is invoked, as described in [Parameter Validation][]. To enable `%n` support, see [\_set\_printf\_count\_output][set_printf_count_output].

## Flag directives ##

The first optional field in a conversion specification contains *flag directives*, zero or more flag characters that specify output justification and control output of signs, blanks, leading zeros, decimal points, and octal and hexadecimal prefixes. More than one flag directive may appear in a conversion specification, and the flag characters can appear in any order.

### Flag characters ###

<table> 
 <thead> 
 <tr> 
 <th>Flag</th> 
 <th>Meaning</th> 
 <th>Default</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>-</td> 
 <td>Left align the result within the given field width.</td> 
 <td>Right align.</td> 
 </tr> 
 <tr> 
 <td>+</td> 
 <td>Use a sign (+ or -) to prefix the output value if it is of a signed type.</td> 
 <td>Sign appears only for negative signed values (-).</td> 
 </tr> 
 <tr> 
 <td>0</td> 
 <td>If&nbsp;width&nbsp;is prefixed by&nbsp;0, leading zeros are added until the minimum width is reached. If both&nbsp;0&nbsp;and&nbsp;-&nbsp;appear, the&nbsp;0&nbsp;is ignored. If&nbsp;0&nbsp;is specified for an integer format (i,&nbsp;u,&nbsp;x,&nbsp;X,&nbsp;o,&nbsp;d) and a precision specification is also present—for example,&nbsp;<code>%04.d</code>—the&nbsp;0&nbsp;is ignored. If&nbsp;0&nbsp;is specified for the&nbsp;a&nbsp;or&nbsp;A&nbsp;floating-point format, leading zeros are prepended to the mantissa, after the&nbsp;<code>0x</code>&nbsp;or&nbsp;<code>0X</code>&nbsp;prefix.</td> 
 <td>No padding.</td> 
 </tr> 
 <tr> 
 <td>blank&nbsp;(' ')</td> 
 <td>Use a blank to prefix the output value if it is signed and positive. The blank is ignored if both the blank and + flags appear.</td> 
 <td>No blank appears.</td> 
 </tr> 
 <tr> 
 <td>#</td> 
 <td>When it's used with the&nbsp;o,&nbsp;x, or&nbsp;X&nbsp;format, the&nbsp;#&nbsp;flag uses 0, 0x, or 0X, respectively, to prefix any nonzero output value.</td> 
 <td>No blank appears.</td> 
 </tr> 
 <tr> 
 <td>&nbsp;</td> 
 <td>When it's used with the&nbsp;e,&nbsp;E,&nbsp;f,&nbsp;F,&nbsp;a, or&nbsp;A&nbsp;format, the&nbsp;#&nbsp;flag forces the output value to contain a decimal point.</td> 
 <td>Decimal point appears only if digits follow it.</td> 
 </tr> 
 <tr> 
 <td>&nbsp;</td> 
 <td>When it's used with the&nbsp;g&nbsp;or&nbsp;G&nbsp;format, the&nbsp;#&nbsp;flag forces the output value to contain a decimal point and prevents the truncation of trailing zeros. Ignored when used with&nbsp;c,&nbsp;d,&nbsp;i,&nbsp;u, or&nbsp;s.</td> 
 <td>Decimal point appears only if digits follow it. Trailing zeros are truncated.</td> 
 </tr> 
 </tbody> 
</table>

## Width specification ##

In a conversion specification, the optional width specification field appears after any *flags* characters. The *width* argument is a non-negative decimal integer that controls the minimum number of characters that are output. If the number of characters in the output value is less than the specified width, blanks are added to the left or the right of the values—depending on whether the left-alignment flag (**-**) is specified—until the minimum width is reached. If *width* is prefixed by 0, leading zeros are added to integer or floating-point conversions until the minimum width is reached, except when conversion is to an infinity or NaN.

The width specification never causes a value to be truncated. If the number of characters in the output value is greater than the specified width, or if *width* isn't given, all characters of the value are output, subject to the *precision* specification.

If the width specification is an asterisk (`*`), an `int` argument from the argument list supplies the value. The *width* argument must precede the value that's being formatted in the argument list, as shown in this example:

`printf("%0*d", 5, 3); /* 00003 is output */`

A missing or small *width* value in a conversion specification doesn't cause the truncation of an output value. If the result of a conversion is wider than the *width* value, the field expands to contain the conversion result.

## Precision specification ##

In a conversion specification, the third optional field is the precision specification. It consists of a period (.) followed by a non-negative decimal integer that, depending on the conversion type, specifies the number of string characters, the number of decimal places, or the number of significant digits to be output.

Unlike the width specification, the precision specification can cause either truncation of the output value or rounding of a floating-point value. If *precision* is specified as 0, and the value to be converted is 0, the result is no characters output, as shown in this example:

`printf( "%.0d", 0 ); /* No characters output */`

If the precision specification is an asterisk (\*), an `int` argument from the argument list supplies the value. In the argument list, the *precision* argument must precede the value that's being formatted, as shown in this example:

`printf( "%.*f", 3, 3.14159265 ); /* 3.142 output */`

The *type* character determines either the interpretation of *precision* or the default precision when *precision* is omitted, as shown in the following table.

### How Precision Values Affect Type ###

<table> 
 <thead> 
 <tr> 
 <th>Type</th> 
 <th>Meaning</th> 
 <th>Default</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>a,&nbsp;A</td> 
 <td>The precision specifies the number of digits after the point.</td> 
 <td>Default precision is 13. If precision is 0, no decimal point is printed unless the&nbsp;#&nbsp;flag is used.</td> 
 </tr> 
 <tr> 
 <td>c,&nbsp;C</td> 
 <td>The precision has no effect.</td> 
 <td>Character is printed.</td> 
 </tr> 
 <tr> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x,&nbsp;X</td> 
 <td>The precision specifies the minimum number of digits to be printed. If the number of digits in the argument is less than&nbsp;precision, the output value is padded on the left with zeros. The value is not truncated when the number of digits exceeds&nbsp;precision.</td> 
 <td>Default precision is 1.</td> 
 </tr> 
 <tr> 
 <td>e,&nbsp;E</td> 
 <td>The precision specifies the number of digits to be printed after the decimal point. The last printed digit is rounded.</td> 
 <td>Default precision is 6. If&nbsp;precision&nbsp;is 0 or the period (.) appears without a number following it, no decimal point is printed.</td> 
 </tr> 
 <tr> 
 <td>f,&nbsp;F</td> 
 <td>The precision value specifies the number of digits after the decimal point. If a decimal point appears, at least one digit appears before it. The value is rounded to the appropriate number of digits.</td> 
 <td>Default precision is 6. If&nbsp;precision&nbsp;is 0, or if the period (.) appears without a number following it, no decimal point is printed.</td> 
 </tr> 
 <tr> 
 <td>g,&nbsp;G</td> 
 <td>The precision specifies the maximum number of significant digits printed.</td> 
 <td>Six significant digits are printed, and any trailing zeros are truncated.</td> 
 </tr> 
 <tr> 
 <td>s,&nbsp;S</td> 
 <td>The precision specifies the maximum number of characters to be printed. Characters in excess of&nbsp;precision&nbsp;aren't printed.</td> 
 <td>Characters are printed until a null character is encountered.</td> 
 </tr> 
 </tbody> 
</table>

## Argument size specification ##

In a conversion specification, the *size* field is an argument length modifier for the *type* conversion specifier. The *size* field prefixes to the *type* field—**hh**, **h**, **j**, **l** (lowercase L), **L**, **ll**, **t**, **w**, **z**, **I** (uppercase i), **I32**, and **I64**—specify the "size" of the corresponding argument—long or short, 32-bit or 64-bit, single-byte character or wide character—depending on the conversion specifier that they modify. These size prefixes are used with *type* characters in the `printf` and `wprintf` families of functions to specify the interpretation of argument sizes, as shown in the following table. The *size* field is optional for some argument types. When no size prefix is specified, the formatter consumes integer arguments—for example, signed or unsigned `char`, `short`, `int`, `long`, and enumeration types—as 32-bit `int` types, and `float`, `double`, and `long double` floating-point arguments are consumed as 64-bit `double` types. This behavior matches the default argument promotion rules for variable argument lists. For more information about argument promotion, see Ellipses and Default Arguments in [Postfix expressions][]. On both 32-bit and 64-bit systems, the conversion specification of a 64-bit integer argument must include a size prefix of **ll** or **I64**. Otherwise, the behavior of the formatter is undefined.

Some types are different sizes in 32-bit and 64-bit code. For example, `size_t` is 32 bits long in code compiled for x86, and 64 bits in code compiled for x64. To create platform-agnostic formatting code for variable-width types, you can use a variable-width argument size modifier. Alternatively, use a 64-bit argument size modifier and explicitly promote the variable-width argument type to 64 bits. The Microsoft-specific **I** (uppercase i) argument size modifier handles variable-width integer arguments, but we recommend the type-specific **j**, **t**, and **z** modifiers for portability.

### Size Prefixes for printf and wprintf Format-Type Specifiers ###

<table> 
 <thead> 
 <tr> 
 <th>To specify</th> 
 <th>Use prefix</th> 
 <th>With type specifier</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td><code>char</code> <code>unsigned char</code></td> 
 <td>hh</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>short int</code> <code>short unsigned int</code></td> 
 <td>h</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>__int32</code> <code>unsigned __int32</code></td> 
 <td>I32</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>__int64</code> <code>unsigned __int64</code></td> 
 <td>I64</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>intmax_t</code> <code>uintmax_t</code></td> 
 <td>j&nbsp;or&nbsp;I64</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>long double</code></td> 
 <td>l&nbsp;(lowercase L) or&nbsp;L</td> 
 <td>a,&nbsp;A,&nbsp;e,&nbsp;E,&nbsp;f,&nbsp;F,&nbsp;g, or&nbsp;G</td> 
 </tr> 
 <tr> 
 <td><code>long int</code> <code>long unsigned int</code></td> 
 <td>l&nbsp;(lowercase L)</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>long long int</code> <code>unsigned long long int</code></td> 
 <td>ll&nbsp;(lowercase LL)</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>ptrdiff_t</code></td> 
 <td>t&nbsp;or&nbsp;I&nbsp;(uppercase i)</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td><code>size_t</code></td> 
 <td>z&nbsp;or&nbsp;I&nbsp;(uppercase i)</td> 
 <td>d,&nbsp;i,&nbsp;o,&nbsp;u,&nbsp;x, or&nbsp;X</td> 
 </tr> 
 <tr> 
 <td>Single-byte character</td> 
 <td>h</td> 
 <td>c&nbsp;or&nbsp;C</td> 
 </tr> 
 <tr> 
 <td>Wide character</td> 
 <td>l&nbsp;(lowercase L) or&nbsp;w</td> 
 <td>c&nbsp;or&nbsp;C</td> 
 </tr> 
 <tr> 
 <td>Single-byte character string</td> 
 <td>h</td> 
 <td>s,&nbsp;S, or&nbsp;Z</td> 
 </tr> 
 <tr> 
 <td>Wide-character string</td> 
 <td>l&nbsp;(lowercase L) or&nbsp;w</td> 
 <td>s,&nbsp;S, or&nbsp;Z</td> 
 </tr> 
 </tbody> 
</table>

The `ptrdiff_t` and `size_t` types are `__int32` or `unsigned __int32` on 32-bit platforms, and `__int64` or `unsigned __int64` on 64-bit platforms. The **I** (uppercase i), **j**, **t**, and **z** size prefixes take the correct argument width for the platform.

In Visual C++, although `long double` is a distinct type, it has the same internal representation as `double`.

An **hc** or **hC** type specifier is synonymous with **c** in `printf` functions and with **C** in `wprintf` functions. An **lc**, **lC**, **wc**, or **wC** type specifier is synonymous with **C** in `printf` functions and with **c** in `wprintf` functions. An **hs** or **hS** type specifier is synonymous with **s** in `printf` functions and with **S** in `wprintf` functions. An **ls**, **lS**, **ws** or **wS** type specifier is synonymous with **S** in `printf` functions and with **s** in `wprintf` functions.

Note

**Microsoft-specific:** The **I** (uppercase i), **I32**, **I64**, and **w** argument size modifier prefixes are Microsoft extensions and are not ISO C-compatible. The **h** prefix when it's used with data of type `char` and the **l** (lowercase L) prefix when it's used with data of type `double` are Microsoft extensions.

[Link 1]: https://clickhouse.yandex/docs/zh/data_types/int_uint/#zheng-xing-fan-wei
[Link 2]: https://clickhouse.yandex/docs/zh/data_types/int_uint/#wu-fu-hao-zheng-xing-fan-wei
[Za _Disable language extensions]: https://docs.microsoft.com/en-us/cpp/build/reference/za-ze-disable-language-extensions?view=vs-2019
[https_docs.microsoft.com_en-us_cpp_c-runtime-library_format-specification-syntax-printf-and-wprintf-functions_view_vs-2019]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=vs-2019
[Stream I_O]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/stream-i-o?view=vs-2019
[flags]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=vs-2019#flags
[width]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=vs-2019#width
[precision]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=vs-2019#precision
[size]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=vs-2019#size
[type]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=vs-2019#type
[Parameter Validation]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/parameter-validation?view=vs-2019
[Visual C_ change history 2003 - 2015]: https://docs.microsoft.com/en-us/cpp/porting/visual-cpp-change-history-2003-2015?view=vs-2019#stdio_and_conio
[set_output_format]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/set-output-format?view=vs-2019
[set_printf_count_output]: https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/set-printf-count-output?view=vs-2019
[Postfix expressions]: https://docs.microsoft.com/en-us/cpp/cpp/postfix-expressions?view=vs-2019