157 lines
7.5 KiB
Groff
157 lines
7.5 KiB
Groff
|
|
NAME
|
|
printf, fprintf, sprintf - print formatted output
|
|
SYNTAX
|
|
#include <stdio.h>
|
|
int printf (format [ , arg ] ... )
|
|
char *format;
|
|
int fprintf (stream, format [ , arg ] ... )
|
|
FILE *stream;
|
|
char *format;
|
|
int sprintf (s, format [ , arg ] ... )
|
|
char *s, format;
|
|
DESCRIPTION
|
|
Printf places output on the standard output stream stdout.
|
|
Fprintf places output on the named output stream. Sprintf
|
|
places ``output,'' followed by the null character (\0), in
|
|
consecutive bytes starting at *s; it is the user's
|
|
responsibility to ensure that enough storage is available.
|
|
Each function returns the number of characters transmitted
|
|
(not including the \0 in the case of sprintf), or a negative
|
|
value if an output error was encountered.
|
|
Each of these functions converts, formats, and prints its
|
|
args under control of the format. The format is a character
|
|
string that contains two types of objects: plain
|
|
characters, which are simply copied to the output stream,
|
|
and conversion specifications, each of which results in
|
|
fetching of zero or more args. The results are undefined if
|
|
there are insufficient args for the format. If the format
|
|
is exhausted while args remain, the excess args are simply
|
|
ignored.
|
|
Each conversion specification is introduced by the character
|
|
%. After the %, the following appear in sequence:
|
|
Zero or more flags, which modify the meaning of the
|
|
conversion specification.
|
|
An optional decimal digit string specifying a minimum
|
|
field width. If the converted value has fewer
|
|
characters than the field width, it will be padded on
|
|
the left (or right, if the left-adjustment flag `-',
|
|
described below, has been given) to the field width.
|
|
If the field width for an s conversion is preceded by a
|
|
0, the string is right adjusted with zero-padding on
|
|
the left.
|
|
A precision that gives the minimum number of digits to
|
|
|
|
appear for the d, o, u, x, or X conversions, the number
|
|
of digits to appear after the decimal point for the e
|
|
and f conversions, the maximum number of significant
|
|
digits for the g conversion, or the maximum number of
|
|
characters to be printed from a string in s conversion.
|
|
The precision takes the form of a period (.) followed
|
|
by a decimal digit string; a null digit string is
|
|
treated as zero.
|
|
An optional l (ell) specifying that a following d, o,
|
|
u, x, or X conversion character applies to a long
|
|
integer arg. A l before any other conversion character
|
|
is ignored.
|
|
A character that indicates the type of conversion to be
|
|
applied.
|
|
A field width or precision may be indicated by an asterisk
|
|
(*) instead of a digit string. In this case, an integer arg
|
|
supplies the field width or precision. The arg that is
|
|
actually converted is not fetched until the conversion
|
|
letter is seen, so the args specifying field width or
|
|
precision must appear before the arg (if any) to be
|
|
converted.
|
|
The flag characters and their meanings are:
|
|
- The result of the conversion will be left-
|
|
justified within the field.
|
|
+ The result of a signed conversion will always
|
|
begin with a sign (+ or -).
|
|
blank If the first character of a signed conversion is
|
|
not a sign, a blank will be prefixed to the
|
|
result. This implies that if the blank and +
|
|
flags both appear, the blank flag will be ignored.
|
|
# This flag specifies that the value is to be
|
|
converted to an ``alternate form.'' For c, d, s,
|
|
and u conversions, the flag has no effect. For o
|
|
conversion, it increases the precision to force
|
|
the first digit of the result to be a zero. For x
|
|
or X conversion, a non-zero result will have 0x or
|
|
0X prefixed to it. For e, E, f, g, and G
|
|
conversions, the result will always contain a
|
|
decimal point, even if no digits follow the point
|
|
(normally, a decimal point appears in the result
|
|
of these conversions only if a digit follows it).
|
|
For g and G conversions, trailing zeroes will not
|
|
be removed from the result (which they normally
|
|
are).
|
|
The conversion characters and their meanings are:
|
|
d,o,u,x,x The integer arg is converted to signed decimal,
|
|
unsigned octal, decimal, or hexadecimal notation
|
|
(x and X), respectively; the letters abcdef are
|
|
used for x conversion and the letters ABCDEF for X
|
|
conversion. The precision specifies the minimum
|
|
number of digits to appear; if the value being
|
|
converted can be represented in fewer digits, it
|
|
will be expanded with leading zeroes. (For
|
|
compatibility with older versions, padding with
|
|
leading zeroes may alternatively be specified by
|
|
prepending a zero to the field width. This does
|
|
not imply an octal value for the field width.)
|
|
The default precision is 1. The result of
|
|
converting a zero value with a precision of zero
|
|
is a null string.
|
|
f The float or double arg is converted to decimal
|
|
notation in the style ``[-]ddd.ddd,'' where the
|
|
number of digits after the decimal point is equal
|
|
to the precision specification. If the precision
|
|
is missing, six digits are output; if the
|
|
precision is explicitly 0, no decimal point
|
|
appears.
|
|
e,E The float or double arg is converted in the style
|
|
``[-]d.ddde_dd,'' where there is one digit before
|
|
the decimal point and the number of digits after
|
|
it is equal to the precision; when the precision
|
|
is missing, six digits are produced; if the
|
|
precision is zero, no decimal point appears. The
|
|
E format code will produce a number with E instead
|
|
of e introducing the exponent. The exponent
|
|
always contains at least two digits.
|
|
g,G The float or double arg is printed in style f or e
|
|
(or in style E in the case of a G format code),
|
|
with the precision specifying the number of
|
|
significant digits. The style used depends on the
|
|
value converted: style e will be used only if the
|
|
exponent resulting from the conversion is less
|
|
than -4 or greater than the precision. Trailing
|
|
zeroes are removed from the result; a decimal
|
|
point appears only if it is followed by a digit.
|
|
c The character arg is printed.
|
|
s The arg is taken to be a string (character
|
|
pointer) and characters from the string are
|
|
printed until a null character (\0) is encountered
|
|
or the number of characters indicated by the
|
|
precision specification is reached. If the
|
|
precision is missing, it is taken to be infinite,
|
|
so all characters up to the first null character
|
|
are printed. A NULL value for arg will yield
|
|
undefined results.
|
|
% Print a %; no argument is converted.
|
|
In no case does a non-existent or small field width cause
|
|
truncation of a field; if the result of a conversion is
|
|
wider than the field width, the field is simply expanded to
|
|
contain the conversion result. Characters generated by
|
|
printf and fprintf are printed as if putc(3S) had been
|
|
called.
|
|
EXAMPLES
|
|
To print a date and time in the form ``Sunday, July 3,
|
|
10:02,'' where weekday and month are pointers to null-
|
|
terminated strings:
|
|
printf("%s, %s %d, %d:%.2d", weekday, month, day, hour, min);
|
|
To print pi to 5 decimal places:
|
|
printf("pi = %.5f", 4 * atan(1.0));
|
|
SEE ALSO
|
|
ecvt(3C), putc(3S), scanf(3S), stdio(3S).
|
|
|