Syntax
#include <stdio.h> int printf(const char *format-string, argument-list);Description
printf formats and prints a series of characters and values to the standard output stream stdout. The format-string consists of ordinary characters, escape sequences, and format specifications. The ordinary characters are copied in order of their appearance to stdout. Format specifications, beginning with a percent sign (%), determine the output format for any argument-list following the format-string.
The format-string is read left to right. When the first format specification is found, the value of the first argument after the format-string is converted and output according to the format specification. The second format specification causes the second argument after the format-string to be converted and output, and so on through the end of the format-string. If there are more arguments than there are format specifications, the extra arguments are evaluated and ignored. The results are undefined if there are not enough arguments for all the format specifications. A format specification has the following form:
>>──%──┬────┬──┬───────┬──┬───────┬──┬──────────────┬──┬───┬──type──><
└─n$─┘ └─flags─┘ └─width─┘ └─.──precision─┘ ├─h─┤
├─l─┤
└─L─┘
Each field of the format specification is a single character or number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the associated argument is interpreted as a character, a string, a number, or pointer. The simplest format specification contains only the percent sign and a type character (for example, %s).
The %n$ syntax should always be used when format strings are stored in translatable text such as message catalog files. This is necessary because sentence structures and order of arguments could vary in different languages. For example, in the statement: printf ( format, month, day, year )
The following optional fields control other aspects of the formatting:
Field
h
Each field of the format specification is discussed in detail below. To print a percent sign character, use %%.
In extended mode, printf also converts floating-pointvaluesofNaNandinfinitytothestrings" NAN "or" nan "and" INFINITY "or" infinity " .Thecaseandsignofthestringisdeterminedbytheformatspecifiers . SeeInfinityandNaNSupportformoreinformationoninfinityandNaNvalues .
The type characters and their meanings are given in the following
table: ┌──────────┬────────────────┬────────────────────────────────────────┐│Char
- │Argument │OutputFormat │
│ acter │ │ │
├──────────┼────────────────┼────────────────────────────────────────┤
│ d, i │ Integer │ Signed decimal integer. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ o │ Integer │ Unsigned octal integer. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ u │ Integer │ Unsigned decimal integer. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ x │ Integer │ Unsigned hexadecimal integer, using │
│ │ │ abcdef. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ X │ Integer │ Unsigned hexadecimal integer, using │
│ │ │ ABCDEF. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ f │ Double │ Signed value having the form │
│ │ │ [-]dddd.dddd, where dddd is one or │
│ │ │ more decimal digits. The number of │
│ │ │ digits before the decimal point │
│ │ │ depends on the magnitude of the │
│ │ │ number. The number of digits after │
│ │ │ the decimal point is equal to the │
│ │ │ requested precision. NaN and infinity │
│ │ │ values are printed in lowercase ("nan" │
│ │ │ and "infinity"). │
├──────────┼────────────────┼────────────────────────────────────────┤
│ F │ Double │ In extended mode,identical to the "f" │
│ │ │ format except that NaN and infinity │
│ │ │ values are printed in uppercase ("NAN" │
│ │ │ and "INFINITY"). In modes other than │
│ │ │ extended, "F" is treated like any │
│ │ │ other character not included in this │
│ │ │ table. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ e │ Double │ Signed value having the form │
│ │ │ [-]d.dddd"e"[sign] ddd, where d is a │
│ │ │ single-decimal digit, dddd is one or │
│ │ │ more decimal digits, ddd is 2 or 3 │
│ │ │ decimal digits, and sign is + or -. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ E │ Double │ Identical to the "e" format except │
│ │ │ that "E" introduces the exponent │
│ │ │ instead of "e". │
├──────────┼────────────────┼────────────────────────────────────────┤
│ g │ Double │ Signed value printed in "f" or "e" │
│ │ │ format. The "e" format is used only │
│ │ │ when the exponent of the value is less │
│ │ │ than -4 or greater than precision. │
│ │ │ Trailing zeros are truncated, and the │
│ │ │ decimal point appears only if one or │
│ │ │ more digits follow it. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ G │ Double │ Identical to the "g" format except │
│ │ │ that "G" introduces the exponent │
│ │ │ (where appropriate) instead of "g". │
├──────────┼────────────────┼────────────────────────────────────────┤
│ c │ Character │ Single character. The "int" argument │
│ │ │ is converted to an unsigned character. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ lc, C │ Wide character │ Multibyte character (converted as if │
│ │ │ by a call to wctomb) pointer to an │
│ │ │ array of "char". │
├──────────┼────────────────┼────────────────────────────────────────┤
│ s │ String │ Characters printed up to the first │
│ │ │ null character (\"0") or until preci- │
│ │ │ sion is reached. If you specify a │
│ │ │ null string, "(NULL)" is printed. │
└──────────┴────────────────┴────────────────────────────────────────┘
┌──────────┬────────────────┬────────────────────────────────────────┐
│ ls, S │ Wide-character │ Multibyte characters, printed up to │
│ │ string │ the first "wchar_t" null character │
│ │ │ ("L\0") is encountered in the wide- │
│ │ │ character string, or until the speci- │
│ │ │ fied precision is reached. Conversion │
│ │ │ takes place as if by a call to │
│ │ │ wcstombs. The displayed result does │
│ │ │ not include the terminating null char- │
│ │ │ acter. If you do not specify the pre- │
│ │ │ cision, you must end the │
│ │ │ wide-character string with a null │
│ │ │ character. A partial multibyte char- │
│ │ │ acter cannot be written. If you │
│ │ │ specify a null string, "(NULL)" is │
│ │ │ printed. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ n │ Pointer to │ Number of characters successfully │
│ │ integer │ written so far to the stream or │
│ │ │ buffer; this value is stored in the │
│ │ │ integer whose address is given as the │
│ │ │ argument. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ p │ Pointer │ Pointer to void converted to a │
│ │ │ sequence of printable characters. │
├──────────┼────────────────┼────────────────────────────────────────┤
│ % │ `%' │ Use to print a "%" symbol. │
└──────────┴────────────────┴────────────────────────────────────────┘
The flag characters and their meanings are as follows (notice that
more than one flag can appear in a format specification): ┌───────────┬─────────────────────────────────┬──────────────────────┐
│ Flag │ Meaning │ Default │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ - │ Left-justify the result within │ Right-justify.
│
│ │ the field width. │ │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ + │ Prefix the output value with a │ Sign appears only │
│ │ sign (+ or -) if the output │ for negative signed │
│ │ value is of a signed type. │ values (-). │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ blank(' ')│ Prefix the output value with a │ No blank. │
│ │ blank if the output value is │ │
│ │ signed and positive. The "+" │ │
│ │ flag overrides the blank flag │ │
│ │ if both appear, and a positive │ │
│ │ signed value will be output │ │
│ │ with a sign. │ │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ # │ When used with the "o", "x", or │ No prefix. │
│ │ "X" formats, the "#" flag pre- │ │
│ │ fixes any nonzero output value │ │
│ │ with "0", "0"x, or "0"X, │ │
│ │ respectively. │ │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ # │ When used with the "f", "F", │ Decimal point │
│ │ "e", or "E" formats, the "#" │ appears only if │
│ │ flag forces the output value to │ digits follow it. │
│ │ contain a decimal point in all │ │
│ │ cases. │ │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ # │ When used with the "g" or "G" │ Decimal point │
│ │ formats, the "#" flag forces │ appears only if │
│ │ the output value to contain a │ digits follow it; │
│ │ decimal point in all cases and │ trailing zeros are │
│ │ prevents the truncation of │ truncated. │
│ │ trailing zeros. │ │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ # │ When used with the "ls" format, │ Precision indicates │
│ │ the "#" flag causes precision │ the maximum number │
│ │ to be measured in "wchar_t" │ of bytes to be │
│ │ characters. │ output. │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ "0" │ When used with the "d", "i", │ Space padding. │
│ │ "o", "u", "x", "X", "e", "E", │ │
│ │ "f", "F"" g", or "G" formats, │ │
│ │ the "0" flag causes leading │ │
│ │ "0"'s to pad the output to the │ │
│ │ field width. The "0" flag is │ │
│ │ ignored if precision is speci- │ │
│ │ fied for an integer or if the │ │
│ │ `"-"' flag is specified. │ │
├───────────┼─────────────────────────────────┼──────────────────────┤
│ ' │ Formats with the thousands │ No grouping char- │
│ │ grouping character of the │ acter. │
│ │ appropriate locale for the │ │
│ │ decimal conversions (%i, %d, │ │
│ │ %u, %f, %g, or %G). │ │
└───────────┴─────────────────────────────────┴──────────────────────┘
The # flag should not be used with c, lc, d, i, u, s, or p types.
Width is a nonnegative decimal integer controlling the minimum number of characters printed. If the number of characters in the output value is less than the specified width, blanks are added on the left or the right (depending on whether the - flag is specified) until the minimum width is reached.
Width never causes a value to be truncated; if the number of characters in the output value is greater than the specified width, or width is not given, all characters of the value are printed (subject to the precision specification).
For the ls type, width is specified in bytes. If the number of bytes in the output value is less than the specified width, single-byte blanks are added on the left or the right (depending on whether the - flag is specified) until the minimum width is reached.
The width specification can be an asterisk (* or *n$), in which case an argument from the argument list supplies the value. The width argument must precede the value being formatted in the argument list.
Precision is a nonnegative decimal integer preceded by a period, which specifies the number of characters to be printed or the number of decimal places. Unlike the width specification, the precision can cause truncation of the output value or rounding of a floating-point value.
The precision specification can be an asterisk (* or *n$), in which case an argument from the argument list supplies the value. The precision argument must precede the value being formatted in the argument list.
The interpretation of the precision value and the default when the
precision is omitted depend upon the type, as shown in the
following table: ┌────────┬──────────────────────────────────┬────────────────────────┐
│ Type │ Meaning │ Default │
├────────┼──────────────────────────────────┼────────────────────────┤
│ i │ Precision specifies the minimum │ If precision is "0" or │
│ d │ number of digits to be printed. │ omitted entirely, or │
│ u │ If the number of digits in the │ if the period (.) │
│ o │ argument is less than precision, │ appears without a │
│ x │ the output value is padded on │ number following it, │
│ X │ the left with zeros. The value │ the precision is set │
│ │ is not truncated when the number │ to 1. │
│ │ of digits exceeds precision. │ │
├────────┼──────────────────────────────────┼────────────────────────┤
│ f │ Precision specifies the number │ Default precision is │
│ F │ of digits to be printed after │ six. If precision is │
│ e │ the decimal point. The last │ "0" or the period │
│ E │ digit printed is rounded. │ appears without a │
│ │ │ number following it, │
│ │ │ no decimal point is │
│ │ │ printed. │
├────────┼──────────────────────────────────┼────────────────────────┤
│ g │ Precision specifies the maximum │ All significant digits │
│ G │ number of significant digits │ are printed. │
│ │ printed. │ │
├────────┼──────────────────────────────────┼────────────────────────┤
│ c │ No effect. │ The character is │
│ │ │ printed. │
├────────┼──────────────────────────────────┼────────────────────────┤
│ lc, C │ No effect. │ The "wchar_t" char- │
│ │ │ acter is printed. │
├────────┼──────────────────────────────────┼────────────────────────┤
│ s │ Precision specifies the maximum │ Characters are printed │
│ │ number of characters to be │ until a null character │
│ │ printed. Characters in excess │ is encountered. │
│ │ of precision are not printed. │ │
├────────┼──────────────────────────────────┼────────────────────────┤
│ ls, S │ Precision specifies the maximum │ "wchar_t" characters │
│ │ number of bytes to be printed. │ are printed until a │
│ │ Bytes in excess of precision are │ null character is │
│ │ not printed; however, multibyte │ encountered. │
│ │ integrity is always preserved. │ │
└────────┴──────────────────────────────────┴────────────────────────┘
The printf function returns the number of bytes printed.
This example prints data in a variety of formats.
#include <stdio.h>
int main(void)
{
char ch = 'h',*string = "computer";
int count = 234,hex = 0x10,oct = 010,dec = 10;
double fp = 251.7366;
printf("%d %+d %06d %X %x %o\n\n", count, count, count, count
, count, count);
printf("1234567890123%n4567890123456789\n\n", &count);
printf("Value of count should be 13; count = %d\n\n", count);
printf("%10c%5c\n\n", ch, ch);
printf("%25s\n%25.4s\n\n", string, string);
printf("%f %.2f %e %E\n\n", fp, fp, fp, fp);
printf("%i %i %i\n\n", hex, oct, dec);
return 0;
/****************************************************************************
The output should be:
234 +234 000234 EA ea 352
12345678901234567890123456789
Value of count should be 13; count = 13
h h
computer
comp
251.736600 251.74 2.517366e+02 2.517366E+02
16 8 10
****************************************************************************/
}
Related Information