printf() Write Formatted String to Stdout
#include <stdio.h>
int printf(format-string[,argument...]);
char *format-string; Format control
printf() formats and prints a series of characters and values to
'stdout', the standard output stream.
'format-string' determines what is to be printed and how it is to be
printed out. 'format-string' consists of ordinary characters, escape
sequences, and format specifications.
The 'format-string' is read left to right. When the first format
specification is encountered, the value of the first argument after
the 'format-string' is converted and output according to format
specifications. The second format specification causes the second
argument to be converted and output, and so on.
Returns: The number of characters printed
Notes: If there are more arguments than there are format
specifications, the extra arguments are ignored. The
results are undefined if there are not enough arguments
for all the format specifications. Ordinary characters
are simply copied in the order of their appearance.
If the percent sign is followed by a character that has
no meaning as a format field, the character is copied to
'stdout'.
Escape sequences:
Escape sequences are special character combinations that
can represent whitespace and non-graphic characters.
They are used to specify actions such as carriage returns
and tab movements. Escape sequences consist of a
backslash ('\') followed by a character or combination of
characters:
\n new-line \t horizontal tab
\b backspace \r carriage return
\a bell (alert) \' single quote
\\ backslash \f form-feed
\v vertical tab \" double quotes
\ddd byte value in octal notation
\xdd byte value in hexadecimal notation
If there are arguments following 'format-string', then
'format-string' must contain format specifications that
determine the output format for these arguments. Format
specifications always begin with a percent sign (%) and
have the following form:
%[flags][width][.precision][{F|N|h|l}]type
Each field of the format specification is a single
character or number signifying a particular format
option. The following describes each field.
Type: The 'type' character determines whether the associated
argument is interpreted as a character, string, or
number. The simplest format specification
contains only a percent sign and a 'type' character. (For
example: %s prints a string.) The 'type' characters are:
d Integer Signed decimal integer
i Integer Signed decimal integer
u Integer Unsigned decimal integer
o Integer Unsigned octal integer
x Integer Unsigned hexadecimal integer (abcdef)
X Integer Unsigned hexadecimal integer (ABCDEF)
f Floating point Signed value having the form:
[-]dddd.dddd
where dddd is one or more decimal digits. The number
of digits after the decimal point depends on the
requested precision.
e Floating-point. Signed value having the form
[-]d.dddde[sign]ddd
d is a single decimal digit
dddd is one or more decimal digits
ddd is exactly three decimal digits,
sign is + or -
E Floating-point. Identical to the "e" format above
g Floating-point. Signed value printed in "f" or "e"
format, whichever is more compact for the
given value and precision. (See precision
chart)
G Floating-point. Identical to "g" format, except that "E"
introduces the exponent (where
appropriate) instead of "e".
c Character Single character
s String Characters printed up to the first null
character ('\0') or until 'precision'
is reached.
n Pointer to Number of characters written so far to
the Integer stream or buffer; this value
is stored in the integer whose address is
given as the argument.
p Far pointer Prints the address pointed to by the
argument in the form xxxx:yyyy, where
xxxx is the segment, and yyyy is the
offset. Digits 'x' and 'y' are uppercase
hexadecimal digits; %Np prints
only the offset of the address, yyyy.
Since %p expects a pointer to a far
value, pointer arguments to p must be
cast to 'far' in small-model programs.
Flags: An optional sequence of flag characters controls the
justification of output and printing of signs, blanks,
decimal points, and octal and hexadecimal prefixes. The
flag characters available are:
Flag Action Default
---------------------------------------------------------------
- Left justify the result within Right justify
the field width.
+ Prefix the output value with a Sign appears only
+ or - sign if it is of a signed for negative
type. signed values(-)
blank Prefix the output value with a No blank
blank (ASCII 32) if the output
values is signed and positive;
the "+" flag overrides the blank
flag, and a positive signed value
will be output with a sign.
# When used with o, x, or X, the No prefix
"#" flag prefixes any nonzero
output value with 0, 0x, or 0X,
respectively.
When used with e, E, or f format, Decimal point
the "#" flag forces the output appears only if
value to contain a decimal point digits follow it.
in all cases.
When used with g or G format, As above, and
the "#" flag forces the output zeros are
value to contain a decimal point truncated.
in all cases, and prevents the
truncation of trailing zeros.
Ignored when used with c, d, i, u
, or s.
More than one flag can appear in a format specification.
Width: The optional width specifier is a non-negative decimal
integer specifying the minimum number of characters to
print, padding with blanks and zeros. Width never causes
a value to be truncated. The width specification may be
an asterisk (*). If so, an argument from the argument
list supplies the value; the 'width' argument precedes
the value being formatted in the argument list.
Precision: An optional precision specifier is a non-negative decimal
integer preceded by a period (.) which specifies the
maximum number of characters printed for all or part of
the output field, or the minimum number of digits printed
for integer values. Precision can cause truncation of
the output value, or rounding in the case of a
floating-point value. Here's how precision can affect
different types:
d,i,o,u,x,X: With any of these types, precision specifies the minimum
number of digits to be printed. If number of digits is
less than specified in precision, output is padded on the
left with zeros. The value is not truncated when the
number of digits exceeds precision. By default, if
precision is 0 or omitted, the precision is set to 1.
e,E,f: Precision specifies the number of digits to be printed
after the decimal point. The last printed digit is
rounded. Default precision is 6. If precision is 0 or
the period appears without a number following it, no
decimal point is printed.
g,G: Precision specifies the maximum number of significant
digits printed. By default, all significant digits are
printed.
c: Precision has no effect. By default, one character is
printed.
s: Precision specifies the maximum number of characters to
be printed. Characters in excess of precision are not
printed. By default, characters are printed until a null
character is encountered.
F|N|h|l: 'F' and 'N' are prefixes that allow the user to override
the default addressing conventions of the memory model
being used. 'F' should be used in the small model to
print a value that has been declared 'far', and 'N'
should be used in the medium, large, and huge models for
'near' values. 'F' and 'N' should be used only with the
's' and 'p' type characters, since they are relevant only
with arguments that pass a pointer. 'h' is used as a
prefix with integer types 'd,i,o,u,x,X' to specify that
the argument is a 'short int'. 'l' is used as a prefix
with 'e,E,f,g,G' to show that the argument is 'double',
rather than 'float'.
-------------------------------- Example ---------------------------------
The following statements format and print various data.
#include <stdio.h>
int val = 5559, x;
double lval = 1538.672;
char ch = 'a';
char *string1 = "how to ";
char *string2 = "format and print ";
char *string3 = "data ";
char pause;
main()
{
printf("Here's %saccurately %svarious %s.\n",
string1,string2,string3);
printf("Press any key to continue...");
pause = getchar();
printf("\n\t ASCII Characters and Decimal Equivalents\n\n");
for (x = 0; x < 13; x++)
printf("\t\t%d\t%c\t\t%d\t%c\n",x+65,x+65,x+78,x+78);
printf("Press any key to continue...");
pause = getchar();
printf("\n\ninteger value: %d\n\n",val*2);
printf("floating point values: %.2f %e \n\n",lval,lval);
for (x = 0; x <100; x++)
printf("%c\t",ch);
}
Seealso:
This page last updated on Fri Nov 30 10:48:32 MSK 2001
Copyright © 1992-2001, Vitaly Filatov, Moscow, Russia
Webmaster