vsprintf man page on Xenix

Man page or keyword search:  
man Server   1130 pages
apropos Keyword Search (all sections)
Output format
Xenix logo
[printable version]

PRINTF(3)							     PRINTF(3)

NAME
       fprintf,	 printf, sprintf, vprintf, vfprintf, vsprintf - formatted out‐
       put conversion

SYNOPSIS
       #include <stdio.h>

       printf(format [, arg ] ...  )
       char *format;

       fprintf(stream, format [, arg ] ...  )
       FILE *stream;
       char *format;

       sprintf(s, format [, arg ] ...  )
       char *s, *format;

       #include <varargs.h>
       vprintf(format, args)
       char *format;
       va_list args;

       vfprintf(stream, format, args)
       FILE *stream;
       char *format;
       va_list args;

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

DESCRIPTION
       Printf and vprintf place output on the standard output  stream  stdout.
       Fprintf	and vfprintf place output on the named output stream.  Sprintf
       and vsprintf copy into the string s, followed by	 the  character	 `\0'.
       Printf,	fprintf,  and  sprintf	take variadic argument lists directly,
       while vprintf, vfprintf, and vsprintf use the variable-length  argument
       facilities  of varargs(3) and hence may be called indirectly (see exam‐
       ples).

       Each function converts, formats, and prints  its	 arguments  after  the
       format under control of the format argument; each returns the the total
       number of characters  printed  (not  including  the  trailing  `\0'  in
       sprintf and vsprintf).  Format is a character string which contains two
       types of objects: plain characters, which are simply copied to the out‐
       put stream, and conversion specifications, each of which causes conver‐
       sion and printing of the next successive arg.

       Each conversion specification is introduced by  the  percent  character
       (``%'').	  The  remainder  of the conversion specification includes, in
       the following order,

       ·      Zero or more of the following flags:

	      ·	     a `#' character specifying that the value should be  con‐
		     verted  to	 an ``alternate form''.	 For c, d, i, n, p, s,
		     and u, conversions, this option has  no  effect.	For  o
		     conversions,  the precision of the number is increased to
		     force the first character of the output string to a  zero
		     (except  if a zero value is printed with an explicit pre‐
		     cision of zero).  For x and  X  conversions,  a  non-zero
		     result  has  the  string  0x  (or	0X  for X conversions)
		     prepended to it.  For e, E, f, g, and G, conversions, the
		     result  will  always  contain a decimal point, even if no
		     digits follow it (normally, a decimal  point  appears  in
		     the  results  of  those  conversions only if a digit fol‐
		     lows).  For g and G conversions, trailing zeros  are  not
		     removed from the result as they would otherwise be.

	      ·	     A	zero ``0'' character specifying zero padding.  For all
		     conversions except n, the converted value	is  padded  on
		     the  left	with zeros rather than blanks.	If a precision
		     is given with a numeric conversion ( d, i, o,  u,	i,  x,
		     and X), the ``0'' flag is ignored.

	      ·	     A	minus  sign  (``-'') specifying left adjustment of the
		     converted value in the indicated  field.	Except	for  n
		     conversions,  the	converted value is padded on the right
		     with blanks, rather than  on  the	left  with  blanks  or
		     zeros.  A ``-'' overrides a ``0'' if both are given.

	      ·	     A	space, specifying that a blank should be left before a
		     positive number produced by a signed conversion (	d,  e,
		     E, f, g, G, or i).

	      ·	     a	`+'  character specifying that a sign always be placed
		     before a number produced by a signed conversion.  A ``+''
		     overrides a space if both are used.

       ·      An  optional digit string specifying a field width.  If the con‐
	      verted value has fewer characters than the field width, it  will
	      be  padded on the left (or right, if the left-adjustment flag is
	      used) to make up the field width.

       ·      An optional precision, in the form of a period (``.'')  followed
	      by  an  optional	digit string.  If the digit string is omitted,
	      the precision is taken as zero.  This gives the  minimum	number
	      of  digits  to  appear for d, i, o, u, x, and X conversions, the
	      number of digits to appear after the decimal point for e, E, and
	      f	 conversions,  the  maximum number of significant digits for g
	      and G conversions, or the maximum number	of  characters	to  be
	      printed from a string for s conversions.

       ·      The character h, specifying that a following d, i, o, u, x, or X
	      conversion corresponds to a short	 int  or  unsigned  short  int
	      argument,	 or  that  a  following	 n conversion corresponds to a
	      pointer to a short int argument.

       ·      the character l (ell) specifying that a following d, i, o, u, x,
	      or  X  conversion corresponds to a long int or unsigned long int
	      argument, or that a following  n	conversion  corresponds	 to  a
	      pointer to a long int argument.

       ·      The  character  L	 specifying  that a following e, E, f, g, or G
	      conversion corresponds to a long double argument (but note  that
	      long  double  values  are not currently supported by the VAX and
	      Tahoe compilers).

       ·      A character  which  indicates  the  type	of  conversion	to  be
	      applied.

       A  field	 width	or  precision  may be an asterisk (``*'') instead of a
       digit string.  In this case an int argument supplies the value.	A neg‐
       ative  field  width  is treated as a left adjustment flag followed by a
       positive field width; a negative precision is treated as though it were
       missing.

       The conversion characters and their meanings are:

       diouxX The int (or appropriate variant) argument is converted to signed
	      decimal (d and i), unsigned octal (o), unsigned decimal (u),  or
	      unsigned	hexadecimal (x and X) notation respectively.  The let‐
	      ters abcdef are used for x conversions; the letters  ABCDEF  are
	      used  for X conversions.	The precision, if any, gives the mini‐
	      mum number of digits that must appear; if	 the  converted	 value
	      requires fewer digits, it is padded on the left with zeros.

       DOU    The  long	 int argument is converted to signed decimal, unsigned
	      octal, or unsigned decimal, as if the format had been ld, lo, or
	      lu  respectively.	  These	 conversion characters are deprecated,
	      and will eventually disappear.

       eE      The double argument is  rounded	and  converted	in  the	 style
	       `[-]d.ddde±dd'  where  there  is	 one  digit before the decimal
	       point and the number after is equal to the precision specifica‐
	       tion  for  the argument.	 If the precision is missing, 6 digits
	       are given; if the precision  is	explicitly  zero,  no  decimal
	       point  appears.	An E conversion uses the letter E (rather than
	       e) to introduce the exponent.  The exponent always contains  at
	       least two digits; if the value is zero, the exponent is 00.

       f       The  double  argument is rounded and converted to decimal nota‐
	       tion in the style `[-]ddd.ddd' where the number of digits after
	       the  decimal point is equal to the precision.  If the precision
	       is missing, 6 digits are given; if the precision is  explicitly
	       0,  no  digits  and no decimal point are printed.  If a decimal
	       point appears, at least one digit appears before it.

       g       The double argument is printed in style f or e (or E for G con‐
	       versions).   The	 precision specifies the number of significant
	       digits.	If the precision is missing, 6 digits  are  given;  if
	       the  precision is zero, it is treated as 1.  Style e is used if
	       the exponent from its conversion is less	 than  -4  or  greater
	       than  or	 equal	to  the precision.  Trailing zeros are removed
	       from the fractional part of the result; a decimal point appears
	       only if it is followed by at least one digit.

       c       The  int	 argument  is  converted to an unsigned char , and the
	       resulting character is printed.

       s       The char	 *  argument  is  taken	 to  be	 a  string  (character
	       pointer).   Characters from the string are printed until a null
	       character is reached, or until the number of  characters	 indi‐
	       cated  by  the  precision  have	been printed, whichever occurs
	       first; if a precision is	 given,	 no  null  character  need  be
	       present.

       p       The void * pointer argument is printed in hexadecimal (as if by
	       ``%x'' or ``%lx'').

       n       The number of characters written so  far	 is  stored  into  the
	       integer	indicated  by the int * (or variant) pointer argument.
	       No argument is converted.

       %       Prints 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 expanded to contain it.  Similarly,	 padding  takes	 place
       only if the specified field width exceeds the actual width.

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, %02d:%.2d", weekday, month, day, hour, min);

       To print pi to 5 decimals:

	      printf("pi = %.5f", 4*atan(1.0));

       To allocate a 128 byte string and print into it:

	      #include <stdio.h>
	      #include <varargs.h>
	      char *newfmt(va_alist)
			va_dcl
	      {
			char *p, *malloc(), fmt;
			va_list ap;
			if ((p = malloc(128)) == NULL)
				  return (NULL);
			va_start(ap);
			fmt = va_arg(ap, char *);
			(void) vsprintf(p, fmt, ap);
			va_end(ap);
			return (p);
	      }

SEE ALSO
       putc(3), scanf(3)

BUGS
       The conversion formats ``%D'', ``%O'', and ``%U'' are not standard  and
       are  provided  only  for backward compatibility.	 The effect of padding
       the ``%p'' format with zeros (either by the ``0'' flag or by specifying
       a  precision),  and the benign effect (i.e., none) of the ``#'' flag on
       ``%n'' and ``%p'' conversions, as well as  other	 nonsensical  combina‐
       tions  such  as	``%Ld'', are not standard; such combinations should be
       avoided.

7th Edition		       October 22, 1987			     PRINTF(3)
[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Xenix

List of man pages available for Xenix

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net