printf utility

printf format [arguments…]

utility† formats and outputs its arguments, under control of the format.
format string contains

plain characters are written to standard output,
escape sequences are converted and written to standard output, and

format specifications causes outputing of the next successive argument. The arguments after the first are treated as strings if the corresponding format is c, b or s ; otherwise it is evaluated as a C language constant, except that:

leading plus or minus sign is allowed.
leading apostrophe or quote causes the value is the ASCII code of the next character.

format is reused as often as necessary to satisfy the arguments.
Excess format specifications are evaluated with zero or null as values.

Escape sequences in backslash notation

        \b  backspace     \t  tab   \f  form-feed    \v  vertical tab   \n  new-line  \r  return 
        \'  apostrohpe    \\ backslash 
           \num
           \0num   Write an 8-bit character whose ASCII value is the 1-3 digit octal number num.
           \a      alert bell
           \c      Ignore remaining characters

format is introduced by % followed by, in order: Zero or more flags:

- left adjustment

0 zero padding
A - overrides a 0

+ always output a sign

space space should be left before a positive number for a signed format. ( A + overrides a space)

#

alternate form:

o : the precision is increased to force a leading zero.

x (X) : a non-zero has 0x (0X) prepended .

e, E, f, g, and G , the result always contains a decimal (normally, a decimal appears if a digit follows ).

g G : trailing zeros are not removed

For

c, d and s has no effect.

Field Width:	An optional digit string specifying a field width; if the output string has fewer characters than the field width it will be blank-padded on the left (or right, if the left-adjustment indicator has been given) to make up the field width (note that a leading zero is a flag, but an embedded zero is part of a field width);
Precision:	An optional period, `.', followed by an optional digit string giving a precision which specifies the number of digits to appear after the decimal point, for e and f formats, or the maximum number of characters to be printed from a string; if the digit string is missing, the precision is treated as zero;
Format:	A character which indicates the type of format to use (one of `diouxXfFeEgGaAcsb`). The uppercase formats produce uppercase output . For example: printf " %E %e \n" "1.2" "3.4" 1.200000E+00 3.400000e+00 The floating-point format specifiers (`fFeEgGaA`) may be prefixed by an `L` to request that additional precision be used, if available.

A field width or precision of * uses the next argument for the field width or precision.

The format characters are:

`di o u Xx`	The argument is output as a signed decimal (`d` or `i`), unsigned octal(`o`), unsigned decimal(`u`), or unsigned hexadecimal (`X` or `x`)
`fF`	[-]ddd.ddd where the number of d's after the decimal point is the precision specification for the argument. Default is 6. If the precision is explicitly 0, no digits and no decimal point are output. The `infinity` and `NaN` (NotANumber) are output as `inf` and `nan`
`eE`	`e [-d.ddd+-dd]` where one digit before the decimal point and the number after is the precision specification ; default is 6 digits are produced. The `infinity` and `NaN` (NotANumber) are output as `inf` and `nan`
`gG`	`f (F)` or `e (E)` whichever gives full precision in minimum space.
`aA`	`[-h.hhh+-pd]` where there is one digit before the hexadecimal point and the number after is equal to the precision specification; when the precision is missing, enough digits are produced to convey the argument's exact double-precision floating-point representation. The `infinity` and `NaN` (NotANumber) are output as `inf` and `nan`
`c`	only first character of argument is output
`s`	Characters from the string argument are output until the end is reached or until the number of characters indicated by the precision specification is reached; if the precision is 0 or missing, all characters in the string are output.
`b`	As for `s`, but interpret character escapes in backslash notation in the string argument.
`%`	output a `%`; no argument is used.

The decimal point character is defined in the program's locale (category LC_NUMERIC).

A non-existent or small field width does not truncate a field;
Padding takes place only if the field width exceeds the actual width.

Exit status

0 on success, and >0 if an error occurs. 1 missing format character, invalid format character

Compatibility

The traditional BSD behavior of converting arguments of numeric formats not beginning with a digit to the ASCII code of the first character is not supported.

See

echo(1), printf(3)

STANDARDS The printf command is expected to be mostly compatible with the IEEE Std 1003.2 (``POSIX.2'') specification.

BUGS

Since the floating point numbers are translated from ASCII to floating-point and then back again, floating-point precision may be lost. (By default, the number is translated to an IEEE-754 double-precision value before being printed. The L modifier may produce additional precision, depending on the hardware platform.)

ANSI hexadecimal character constants were deliberately not provided.

The escape sequence \000 is the string terminator. When present in the argument for the b format, the argument will be truncated at the \000 character.

Multibyte characters are not recognized in format strings (this is only a problem if `%' can appear inside a multibyte character).

Parsing of - arguments is also somewhat different from printf(3), where unknown arguments are simply printed instead of being flagged as errors.