int
fwprintf(
FILE * restrict stream
, const wchar_t * restrict format
, ...
)
int
swprintf(
wchar_t * restrict ws
, size_t n
, const wchar_t * restrict format
, ...
)
int
wprintf(
const wchar_t * restrict format
, ...
)
int
vfwprintf(
FILE * restrict stream
, const wchar_t * restrict
, va_list ap
)
int
vswprintf(
wchar_t * restrict ws
, size_t n
, const wchar_t *restrict format
, va_list ap
)
int
vwprintf(
const wchar_t * restrict format
, va_list ap
)
)
family of functions produces output according to a
format
as described below.
The
wprintf(
)
and
vwprintf(
)
functions
write output to
stdout
,
the standard output stream;
fwprintf(
)
and
vfwprintf(
)
write output to the given output
stream
;
swprintf(
)
and
vswprintf(
)
write to the wide character string
ws
.
These functions write the output under the control of a
format
string that specifies how subsequent arguments
(or arguments accessed via the variable-length argument facilities of
stdarg(3))
are converted for output.
These functions return the number of characters printed (not including the trailing `\0' used to end output to strings).
The
swprintf()
and
vswprintf(
)
functions will fail if
n
or more wide characters were requested to be written,
The format string is composed of zero or more directives: ordinary characters (not %), which are copied unchanged to the output stream; and conversion specifications, each of which results in fetching zero or more subsequent arguments. Each conversion specification is introduced by the % character. The arguments must correspond properly (after type promotion) with the conversion specifier. After the %, the following appear in sequence:
Modifier | d, i | o, u, x, X | n |
hh | Vt signed char | Vt unsigned char | Vt signed char * |
h | Vt short | Vt unsigned short | Vt short * |
l (ell) | Vt long | Vt unsigned long | Vt long * |
ll (ell ell) | Vt | long long Vt unsigned long long | Vtlong long * |
j | Vt intmax_t | Vt uintmax_t | Vt intmax_t * |
t | Vt ptrdiff_t | (see note) | Vt ptrdiff_t * |
z | (see note) | Vt size_t | (see note) |
q (deprecated) Vt quad_t | Vt u_quad_t | Vt quad_t *
| |
Note: the t modifier, when applied to a o, u, x, or X conversion, indicates that the argument is of an unsigned type equivalent in size to a The z modifier, when applied to a d or i conversion, indicates that the argument is of a signed type equivalent in size to a Similarly, when applied to an n conversion, it indicates that the argument is a pointer to a signed type equivalent in size to a
The following length modifier is valid for the a, A, e, E, f, F, g, or G conversion:
Modifier | a, A, e, E, f, F, g, G |
L | Vt long double |
The following length modifier is valid for the c or s conversion:
Modifier | c | s |
l (ell) | Vt wint_t | Vt wchar_t * |
A field width or precision, or both, may be indicated by
an asterisk
`*'
or an asterisk followed by one or more decimal digits and a
`$'
instead of a
digit string.
In this case, an
argument supplies the field width or precision.
A negative field width is treated as a left adjustment flag followed by a
positive field width; a negative precision is treated as though it were
missing.
If a single format directive mixes positional
(nn$
)
and non-positional arguments, the results are undefined.
The conversion specifiers and their meanings are:
abcdef
''
are used for
x
conversions; the letters
``
ABCDEF
''
are used for
X
conversions.
The precision, if any, gives the minimum number of digits that must
appear; if the converted value requires fewer digits, it is padded on
the left with zeros.
.
ddd
e
dd]
where there is one digit before the
decimal-point character
and the number of digits after it is equal to the precision;
if the precision is missing,
it is taken as 6; if the precision is
zero, no decimal-point character appears.
An
E
conversion uses the letter
`E'
(rather than
`e')
to introduce the exponent.
The exponent always contains at least two digits; if the value is zero,
the exponent is 00.
For
a, A, e, E, f, F, g,
and
G
conversions, positive and negative infinity are represented as
inf
and
-inf
respectively when using the lowercase conversion character, and
INF
and
-INF
respectively when using the uppercase conversion character.
Similarly, NaN is represented as
nan
when using the lowercase conversion, and
NAN
when using the uppercase conversion.
.
ddd,]
where the number of digits after the decimal-point character
is equal to the precision specification.
If the precision is missing, it is taken as 6; if the precision is
explicitly zero, no decimal-point character appears.
If a decimal point appears, at least one digit appears before it.
0x
h
.
hhhp [.blm Pp d,]]
where the number of digits after the hexadecimal-point character
is equal to the precision specification.
If the precision is missing, it is taken as enough to exactly
represent the floating-point number; if the precision is
explicitly zero, no hexadecimal-point character appears.
This is an exact conversion of the mantissa+exponent internal
floating point representation; the
-[.blm Pp
0x
h
.
hhh]
portion represents exactly the mantissa; only denormalized
mantissas have a zero value to the left of the hexadecimal
point.
The
p
is a literal character
`p';
the exponent is preceded by a positive or negative sign
and is represented in decimal, using only enough characters
to represent the exponent.
The
A
conversion uses the prefix
``
0X
''
(rather than
``
0x
''),
the letters
``
ABCDEF
''
(rather than
``
abcdef
'')
to represent the hex digits, and the letter
`P'
(rather than
`p')
to separate the mantissa and exponent.
If the l (ell) modifier is used, the argument is converted to a and written.
NUL
character;
if a precision is specified, no more than the number specified are
written.
If a precision is given, no null character
need be present; if the precision is not specified, or is greater than
the size of the array, the array must contain a terminating
NUL
character.
If the
l
(ell) modifier is used, the
argument is expected to be a pointer to an array of wide characters
(pointer to a wide string).
Each wide character in the string
is written.
Wide characters from the array are written up to (but not including)
a terminating wide
NUL
character;
if a precision is specified, no more than the number specified are
written (including shift sequences).
If a precision is given, no null character
need be present; if the precision is not specified, or is greater than
the number of characters in
the string, the array must contain a terminating wide
NUL
character.
The decimal point
character is defined in the program's locale (category
LC_NUMERIC
).
In no case does a non-existent or small field width cause truncation of a numeric field; if the result of a conversion is wider than the field width, the field is expanded to contain the conversion result.
),
fwprintf(
),
swprintf(
),
vwprintf(
),
vfwprintf(
)
and
vswprintf(
)
functions
conform to
ISO/IEC 9899:1999 (``ISO C99'') .