Unix/Linux Go Back    

Plan 9 - man page for fprintf (plan9 section 2)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

FPRINTF(2)									       FPRINTF(2)

       fprintf, printf, sprintf, vfprintf, vprintf,  vsprintf - print formatted output

       #include <stdio.h>

       int fprintf(FILE *f, char *format, ...);

       int printf(char *format, ...);

       int sprintf(char *s, char *format, ...);

       int vfprintf(FILE *f, char *format, char *args);

       int vprintf(char *format, char *args);

       int vsprintf(char *s, char *format, char *args);

       Fprintf	places	output on the named output stream f (see fopen(2)).  Printf places output
       on the standard output stream stdout.  Sprintf places output followed by the null  charac-
       ter  (\0)  in  consecutive  bytes starting at s; it is the user's responsibility to ensure
       that enough storage is available.  Vfprintf, vprintf, and vsprintf are  the  same,  except
       the args argument is a pointer to an argument in an argument list of the calling function,
       and the effect is as if the calling function's argument list from that point on is  passed
       to the printf routines.

       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.

       These functions convert, format, and print their trailing arguments  under  control  of	a
       format string.  The format contains two types of objects: plain characters, which are sim-
       ply copied to the output stream, and conversion specifications, each of which  results  in
       fetching  of  zero or more arguments.  The results are undefined if there are arguments of
       the wrong type or too few arguments for the format.  If	the  format  is  exhausted  while
       arguments remain, the excess are ignored.

       Each  conversion specification is introduced by the character %.  After the %, the follow-
       ing 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  con-
	      verted value has fewer characters than the field width, it will be padded with spa-
	      ces on the left (or right, if the left adjustment, described later, has been given)
	      to the field width.

	      An  optional precision that gives the minimum number of digits to appear for the d,
	      i, o, u, x, and X conversions, the number of digits to  appear  after  the  decimal
	      point for the e, E, and f conversions, the maximum number of significant digits for
	      the g and G conversions, or the maximum number of characters to be written  from	a
	      string  in s conversion.	The precision takes the form of a period (.)  followed by
	      an optional decimal integer; if the integer is omitted, it is treated as zero.

	      An optional h specifying that a following d, i, o, u, x or X  conversion	specifier
	      applies to a short int or unsigned short argument (the argument will have been pro-
	      moted according to the integral promotions, and its value  shall	be  converted  to
	      short or unsigned short before printing); an optional h specifying that a following
	      n conversion specifier applies to a pointer to a	short  argument;  an  optional	l
	      (ell)  specifying that a following d, i, o, u, x, or X conversion character applies
	      to a long or unsigned long argument; an optional l specifying that  a  following	n
	      conversion  specifier applies to a pointer to a long int argument; or an optional L
	      specifying that a following e, E, f, g, or G conversion specifier applies to a long
	      double argument.	If an h, l, or L appears with any other conversion specifier, the
	      behavior is undefined.

	      A character that indicates the type of conversion to be applied.

       A field width or precision, or both, may be indicated by an  asterisk  (*)  instead  of	a
       digit  string.  In this case, an int arg supplies the field width or precision.	The argu-
       ments specifying field width or precision, or both, shall appear (in  that  order)  before
       the  argument  (if  any) to be converted.  A negative field width argument is taken as a -
       flag followed by a positive field width.  A negative precision is  taken  as  if  it  were

       The flag characters and their meanings are:
       -	 The result of the conversion is left-justified within the field.
       +	 The result of a signed conversion always begins with a sign (+ or -).
       blank	 If the first character of a signed conversion is not a sign, or a signed conver-
		 sion results in no characters, a blank is prefixed to the result.  This  implies
		 that if the blank and + flags both appear, the blank flag is ignored.
       #	 The  result  is  to be converted to an ``alternate form.''  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 has 0x or 0X prefixed to it.	For e, E,
		 f, g, and G conversions, the result always contains 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,  trail-
		 ing  zeros  are  not be removed from the result as they normally are.	For other
		 conversions, the behavior is undefined.
       0	 For d, i, o, u, x, X, e, E, f, g, and G conversions,  leading	zeros  (following
		 any  indication  of sign or base) are used to pad the field width; no space pad-
		 ding is performed.  If the 0 and -  flags  both  appear,  the	0  flag  will  be
		 ignored.  For d, i, o, u, x, and X conversions, if a precision is specified, the
		 0 flag will be ignored.  For other conversions, the behavior is undefined.

       The conversion characters and their meanings are:

       d,o,u,x,X The integer arg is converted to signed decimal (d or  i),  unsigned  octal  (o),
		 unsigned  decimal  (u),  or  unsigned hexadecimal notation (x or X); 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 is expanded with leading zeros.
		 The default precision is 1.  The result of converting a zero value with a preci-
		 sion of zero is no characters.
       f	 The double argument 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, it is taken as 6; if the	precision
		 is explicitly no decimal point appears.
       e,E	 The  double argument 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, it is taken as 6; if the precision is
		 zero, no decimal point appears.  The E format code  produces  a  number  with	E
		 instead  of  e  introducing the exponent.  The exponent always contains at least
		 two digits.
       g,G	 The double argument is printed in style f or e (or in style E in the case of a G
		 conversion  specifier),  with the precision specifying the number of significant
		 digits.  If an explicit precision is zero, it is taken as  1.	 The  style  used
		 depends  on  the value converted: style e is used only if the exponent resulting
		 from the conversion is less than -4 or greater than or equal to  the  precision.
		 Trailing  zeros are removed from the fractional portion of the result; a decimal
		 point appears only if it is followed by a digit.
       c	 The int argument is converted to an unsigned char, and the  resulting	character
		 is written.
       s	 The argument 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 preci-
		 sion is missing, it is taken to be infinite, so all characters up to  the  first
		 null  character  are  printed.   A  zero value for the argument yields undefined
       P	 The void * argument is printed in an implementation defined way (for Plan 9: the
		 address as hexadecimal number).
       n	 The  argument	shall be a pointer to an integer into which is written the number
		 of characters written to the output stream so far by this call to  fprintf.   No
		 argument is converted.
       %	 Print a %; no argument is converted.

       If a conversion specification is invalid, the behavior is undefined.

       If  any argument is, or points to, a union or an aggregate (except for an array of charac-
       ter type using %s conversion, or a pointer cast to be a pointer to void using  %P  conver-
       sion), the behavior is undefined.

       In  no  case  does  a nonexistent or small field width cause truncation of a field; if the
       result of a conversion is wider than the field width, the field is expanded to contain the
       conversion result.


       fopen(2), fscanf(2), print(2)

       There is no way to print a wide character (rune); use print(2) or bio(2).

Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 11:37 PM.