sprintf
, fprintf
, printf
, snprintf
, asprintf
, asnprintf
—format output#include <stdio.h> int printf(const char *format, ...); int fprintf(FILE *fd, const char *format, ...); int sprintf(char *str, const char *format, ...); int snprintf(char *str, size_t size, const char *format, ...); int asprintf(char **strp, const char *format, ...); char *asnprintf(char *str, size_t *size, const char *format, ...); int _printf_r(struct _reent *ptr, const char *format, ...); int _fprintf_r(struct _reent *ptr, FILE *fd, const char *format, ...); int _sprintf_r(struct _reent *ptr, char *str, const char *format, ...); int _snprintf_r(struct _reent *ptr, char *str, size_t size, const char *format, ...); int _asprintf_r(struct _reent *ptr, char **strp, const char *format, ...); char *_asnprintf_r(struct _reent *ptr, char *str, size_t *size, const char *format, ...);
Description
printf
accepts a series of arguments, applies to each a
format specifier from *
format, and writes the
formatted data to stdout
, without a terminating NUL
character. The behavior of printf
is undefined if there
are not enough arguments for the format. printf
returns
when it reaches the end of the format string. If there are
more arguments than the format requires, excess arguments are
ignored.
fprintf
is like printf
, except that output is directed
to the stream fd rather than stdout
.
sprintf
is like printf
, except that output is directed
to the buffer str, and a terminating NUL is output.
Behavior is undefined if more output is generated than the
buffer can hold.
snprintf
is like sprintf
, except that output is
limited to at most size bytes, including the terminating
NUL
. As a special case, if size is 0, str can be
NULL, and snprintf
merely calculates how many bytes would
be printed.
asprintf
is like sprintf
, except that the output is
stored in a dynamically allocated buffer, pstr, which
should be freed later with free
.
asnprintf
is like sprintf
, except that the return type
is either the original str if it was large enough, or a
dynamically allocated string if the output exceeds *size;
the length of the result is returned in *size. When
dynamic allocation occurs, the contents of the original
str may have been modified.
For sprintf
, snprintf
, and asnprintf
, the behavior
is undefined if the output *
str overlaps with one of
the arguments. Behavior is also undefined if the argument for
%n
within *
format overlaps another argument.
format is a pointer to a character string containing two
types of objects: ordinary characters (other than %
),
which are copied unchanged to the output, and conversion
specifications, each of which is introduced by %
. (To
include %
in the output, use %%
in the format string.)
A conversion specification has the following form:
%[pos][flags][width][.prec][size]type
The fields of the conversion specification have the following meanings:
Conversions normally consume arguments in the order that they
are presented. However, it is possible to consume arguments
out of order, and reuse an argument for more than one
conversion specification (although the behavior is undefined
if the same argument is requested with different types), by
specifying pos, which is a decimal integer followed by
'$'. The integer must be between 1 and <NL_ARGMAX> from
limits.h, and if argument %n$
is requested, all earlier
arguments must be requested somewhere within format. If
positional parameters are used, then all conversion
specifications except for %%
must specify a position.
This positional parameters method is a POSIX extension to the C
standard definition for the functions.
flags is an optional sequence of characters which control
output justification, numeric signs, decimal points, trailing
zeros, and octal and hex prefixes. The flag characters are
minus (-
), plus (+
), space ( ), zero (0
), sharp
(#
), and quote ('
). They can appear in any
combination, although not all flags can be used for all
conversion specification types.
'
i
,
d
, u
, f
, F
, g
, or G
, the
integer portion of the conversion would be formatted
with thousands' grouping wide characters.)
-
+
d
, i
, a
,
A
, e
, E
, f
, F
, g
, or
G
) will always begin with a plus or minus
sign. (If you do not use this flag, positive
values do not begin with a plus sign.)
" " (space)
+
) flag both
appear, the space flag is ignored.
0
d
, i
,
o
, u
, x
, X
, a
, A
,
e
, E
, f
, F
, g
, or G
: leading
zeros are used to pad the field width
(following any indication of sign or base); no
spaces are used for padding. If the zero
(0
) and minus (-
) flags both appear,
the zero (0
) flag will be ignored. For
d
, i
, o
, u
, x
, and X
conversions, if a precision prec is
specified, the zero (0
) flag is ignored.
Note that 0
is interpreted as a flag, not
as the beginning of a field width.
#
o
x
0x
prefix.
X
0X
prefix.
a, A, e, E, f, or F
g or G
all others
width is an optional minimum field width. You can
either specify it directly as a decimal integer, or
indirectly by using instead an asterisk (*
), in
which case an int
argument is used as the field
width. If positional arguments are used, then the
width must also be specified positionally as *m$
,
with m as a decimal integer. Negative field widths
are treated as specifying the minus (-
) flag for
left justfication, along with a positive field width.
The resulting format may be wider than the specified
width.
prec is an optional field; if present, it is
introduced with `.
' (a period). You can specify
the precision either directly as a decimal integer or
indirectly by using an asterisk (*
), in which case
an int
argument is used as the precision. If
positional arguments are used, then the precision must
also be specified positionally as *m$
, with m as a
decimal integer. Supplying a negative precision is
equivalent to omitting the precision. If only a
period is specified the precision is zero. The effect
depends on the conversion type.
d, i, o, u, x, or X
a or A
e, E, f or F
g or G
s or S
all others
size is an optional modifier that changes the data type that the corresponding argument has. Behavior is unspecified if a size is given that does not match the type.
hh
d
, i
, o
, u
, x
, or
X
, specifies that the argument should be
converted to a signed char
or unsigned
char
before printing.
With n
, specifies that the argument is a
pointer to a signed char
.
h
d
, i
, o
, u
, x
, or
X
, specifies that the argument should be
converted to a short
or unsigned short
before printing.
With n
, specifies that the argument is a
pointer to a short
.
l
d
, i
, o
, u
, x
, or
X
, specifies that the argument is a
long
or unsigned long
.
With c
, specifies that the argument has
type wint_t
.
With s
, specifies that the argument is a
pointer to wchar_t
.
With n
, specifies that the argument is a
pointer to a long
.
With a
, A
, e
, E
, f
, F
,
g
, or G
, has no effect (because of
vararg promotion rules, there is no need to
distinguish between float
and double
).
ll
d
, i
, o
, u
, x
, or
X
, specifies that the argument is a
long long
or unsigned long long
.
With n
, specifies that the argument is a
pointer to a long long
.
j
d
, i
, o
, u
, x
, or
X
, specifies that the argument is an
intmax_t
or uintmax_t
.
With n
, specifies that the argument is a
pointer to an intmax_t
.
z
d
, i
, o
, u
, x
, or
X
, specifies that the argument is a size_t
.
With n
, specifies that the argument is a
pointer to a size_t
.
t
d
, i
, o
, u
, x
, or
X
, specifies that the argument is a
ptrdiff_t
.
With n
, specifies that the argument is a
pointer to a ptrdiff_t
.
L
a
, A
, e
, E
, f
, F
,
g
, or G
, specifies that the argument
is a long double
.
type specifies what kind of conversion printf
performs. Here is a table of these:
%
%
).
c
l
size specifier is in effect, a multibyte
character is printed.
C
%lc
. A POSIX extension to the C standard.
s
char
until the precision or a null character is
reached. If the l
size specifier is in
effect, the pointer is to an array of
wchar_t
, and the string is converted to
multibyte characters before printing.
S
%ls
. A POSIX extension to the C standard.
d or i
int
. Leading zeros are inserted as
necessary to reach the precision. A value of 0 with
a precision of 0 produces an empty string.
D
%ld
.
o
unsigned
. Leading zeros are inserted as
necessary to reach the precision. A value of 0 with
a precision of 0 produces an empty string.
O
%lo
.
u
unsigned
. Leading zeros are inserted as
necessary to reach the precision. A value of 0 with
a precision of 0 produces an empty string.
U
%lu
.
x
abcdef
as digits beyond 9
); takes an
unsigned
. Leading zeros are inserted as
necessary to reach the precision. A value of 0 with
a precision of 0 produces an empty string.
X
x
, but uses ABCDEF
as digits
beyond 9
.
f
[-]9999.9999
, with the precision
determining how many digits follow the decimal
point; takes a double
(remember that
float
promotes to double
as a vararg).
The low order digit is rounded to even. If
the precision results in at most DECIMAL_DIG
digits, the result is rounded correctly; if
more than DECIMAL_DIG digits are printed, the
result is only guaranteed to round back to the
original value.
If the value is infinite, the result is
inf
, and no zero padding is performed. If
the value is not a number, the result is
nan
, and no zero padding is performed.
F
f
, but uses INF
and NAN
for
non-finite numbers.
e
[-]9.9999e[+|-]999
; takes a double
.
The digit before the decimal point is non-zero
if the value is non-zero. The precision
determines how many digits appear between
.
and e
, and the exponent always
contains at least two digits. The value zero
has an exponent of zero. If the value is not
finite, it is printed like f
.
E
e
, but using E
to introduce the
exponent, and like F
for non-finite
values.
g
f
or e
form, based on the given value and
precision—an exponent less than -4 or
greater than the precision selects the e
form. Trailing zeros and the decimal point
are printed only if necessary; takes a
double
.
G
g
, except use F
or E
form.
a
[-]0x1.ffffp[+|-]9
; takes a double
.
The letters abcdef
are used for digits
beyond 9
. The precision determines how
many digits appear after the decimal point.
The exponent contains at least one digit, and
is a decimal value representing the power of
2; a value of 0 has an exponent of 0.
Non-finite values are printed like f
.
A
a
, except uses X
, P
, and
ABCDEF
instead of lower case.
n
int
, and stores a count
of the number of bytes written so far. No
output is created.
p
void
, and prints it in
an implementation-defined format. This
implementation is similar to %#tx
), except
that 0x
appears even for the NULL pointer.
_printf_r
, _fprintf_r
, _asprintf_r
,
_sprintf_r
, _snprintf_r
, _asnprintf_r
are simply
reentrant versions of the functions above.
Returns
On success, sprintf
and asprintf
return the number of bytes in
the output string, except the concluding NUL
is not counted.
snprintf
returns the number of bytes that would be in the output
string, except the concluding NUL
is not counted. printf
and
fprintf
return the number of characters transmitted.
asnprintf
returns the original str if there was enough room,
otherwise it returns an allocated string.
If an error occurs, the result of printf
, fprintf
,
snprintf
, and asprintf
is a negative value, and the result of
asnprintf
is NULL. No error returns occur for sprintf
. For
printf
and fprintf
, errno
may be set according to
fputc
. For asprintf
and asnprintf
, errno
may be set
to ENOMEM if allocation fails, and for snprintf
, errno
may be
set to EOVERFLOW if size or the output length exceeds INT_MAX.
Bugs
The “”' (quote) flag does not work when locale's thousands_sep is not empty.
Portability
ANSI C requires printf
, fprintf
, sprintf
, and
snprintf
. asprintf
and asnprintf
are newlib extensions.
The ANSI C standard specifies that implementations must support at least formatted output of up to 509 characters. This implementation has no inherent limit.
Depending on how newlib was configured, not all format specifiers are supported.
Supporting OS subroutines required: close
, fstat
, isatty
,
lseek
, read
, sbrk
, write
.