printf(3c) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨페이지이름
검색(S)

printf

Name
     printf, fprintf, sprintf, snprintf, asprintf - print format-
     ted output

Synopsis
     #include <stdio.h>

     int printf(const char *restrict format,
          /* args*/ ...);


     int fprintf(FILE *restrict stream, const char *restrict format,
          /* args*/ ...);


     int sprintf(char *restrict s, const char *restrict format,
          /* args*/ ...);


     int snprintf(char *restrict s, size_t n,
          const char *restrict format, /* args*/ ...);


     int asprintf(char ** ret, const char *restrict format,
          /* args*/ ...);

Description
     The printf() function places output on the  standard  output
     stream stdout.


     The fprintf() function places output on on the named  output
     stream stream.


     The sprintf() function places output, followed by  the  null
     byte  (\0),  in  consecutive  bytes starting at s; it is the
     user's responsibility  to  ensure  that  enough  storage  is
     available.


     The snprintf() function is identical to sprintf()  with  the
     addition  of the argument n, which specifies the size of the
     buffer referred to by s. If n is 0, nothing is written and s
     can  be  a  null pointer. Otherwise, output bytes beyond the
     n-1st are discarded instead of being written  to  the  array
     and  a null byte is written at the end of the bytes actually
     written into the array.

     The asprintf() function is the same as the  sprintf()  func-
     tion  except that it returns, in the ret argument, a pointer
     to a buffer sufficiently large to hold  the  output  string.
     This  pointer  should  be  passed to free(3C) to release the
     allocated storage when it is no longer needed. If sufficient
     space  cannot  be allocated, the asprintf() function returns
     -1 and sets ret to be a NULL pointer.


     Each of these functions converts, formats,  and  prints  its
     arguments under control of the format. The format is a char-
     acter string, beginning and  ending  in  its  initial  shift
     state, if any. The format is composed of zero or more direc-
     tives: ordinary characters, which are simply copied  to  the
     output  stream  and conversion specifications, each of which
     results in the fetching  of  zero  or  more  arguments.  The
     results  are  undefined  if there are insufficient arguments
     for the format. If the format is exhausted  while  arguments
     remain, the excess arguments are evaluated but are otherwise
     ignored.


     Conversions can be applied to the  nth  argument  after  the
     format  in the argument list, rather than to the next unused
     argument. In this case,  the  conversion  specifier  %  (see
     below) is replaced by the sequence %n$, where n is a decimal
     integer in the range [1, NL_ARGMAX], giving the position  of
     the argument in the argument list. This feature provides for
     the definition of format strings that select arguments in an
     order  appropriate  to  specific languages (see the EXAMPLES
     section).


     In format strings containing  the  %n$  form  of  conversion
     specifications,  numbered arguments in the argument list can
     be referenced from  the  format  string  as  many  times  as
     required.


     In format  strings  containing  the  %  form  of  conversion
     specifications,  each  argument in the argument list is used
     exactly once.


     All forms of the printf() functions allow for the  insertion
     of  a  language-dependent  radix  character  in  the  output
     string. The radix character  is  defined  by  the  program's
     locale  (category  LC_NUMERIC). In the POSIX locale, or in a
     locale where the radix character is not defined,  the  radix
     character defaults to a period (.).

  Conversion Specifications
     Each conversion specification is introduced by the % charac-
     ter  or  by the character sequence %n$, after which the fol-
     lowing appear in sequence:

         o    An optional field, consisting of  a  decimal  digit
              string  followed  by a $, specifying the next argu-
              ment to be converted. If this  field  is  not  pro-
              vided,  the  args  following the last argument con-
              verted will be used.

         o    Zero or more flags (in any order), which modify the
              meaning of the conversion specification.

         o    An optional minimum field width. If  the  converted
              value has fewer bytes than the field width, it will
              be padded with spaces by default on  the  left;  it
              will be padded on the right, if the left-adjustment
              flag (-), described below, is given  to  the  field
              width.  The field width takes the form of an aster-
              isk (*), described below, or a decimal integer.

              If the  conversion  specifier  is  s,  a  standard-
              conforming  application  (see  standards(5)) inter-
              prets the field width  as  the  minimum  number  of
              bytes  to  be  printed;  an application that is not
              standard-conforming interprets the field  width  as
              the  minimum  number  of columns of screen display.
              For an application that is not standard-conforming,
              %10s  means  if  the  converted  value has a screen
              width of 7 columns, 3 spaces would be padded on the
              right.

              If the format is %ws, then the field  width  should
              be  interpreted as the minimum number of columns of
              screen display.

         o    An optional precision that gives the minimum number
              of  digits  to  appear for the d, i, o, u, x, and X
              conversions  (the  field  is  padded  with  leading
              zeros);  the  number  of digits to appear after the
              radix character for the  a,  A,  e,  E,  f,  and  F
              conversions,  the  maximum  number  of  significant
              digits for the g and G conversions; or the  maximum
              number  of  bytes  to be printed from a string in s
              and S conversions. The precision takes the form  of
              a  period  (.)  followed either by an asterisk (*),
              described  below,  or  an  optional  decimal  digit
              string,  where a null digit string is treated as 0.
              If a precision appears with  any  other  conversion
              specifier, the behavior is undefined.

              If the conversion specifier is s or S, a  standard-
              conforming  application  (see  standards(5)) inter-
              prets the precision as the maximum number of  bytes
              to   be   written;   an  application  that  is  not
              standard-conforming interprets the precision as the
              maximum number of columns of screen display. For an
              application that is not  standard-conforming,  %.5s
              would  print  only  the  portion of the string that
              would display in 5 screen  columns.  Only  complete
              characters are written.

              For %ws, the precision should be interpreted as the
              maximum  number  of  columns of screen display. The
              precision takes the form of a period  (.)  followed
              by  a  decimal digit string; a null digit string is
              treated as zero. Padding specified by the precision
              overrides the padding specified by the field width.

         o    An optional length modifier that specified the size
              of the argument.

         o    A conversion specifier that indicates the  type  of
              conversion to be applied.


     A field width, or precision, or both can be indicated by  an
     asterisk  (*)  .  In this case, an argument of type int sup-
     plies the field width  or  precision.  Arguments  specifying
     field width, or precision, or both must appear in that order
     before the argument, if any, to  be  converted.  A  negative
     field  width  is  taken  as  a - flag followed by a positive
     field width. A negative precision is taken as if the  preci-
     sion were omitted. In format strings containing the %n$ form
     of a conversion specification, a field  width  or  precision
     may  be  indicated by the sequence *m$, where m is a decimal
     integer in the range [1, NL_ARGMAX] giving the  position  in
     the  argument list (after the format argument) of an integer
     argument containing the field width or precision, for  exam-
     ple:

       printf("%1$d:%2$.*3$d:%4$.*3$d\n", hour, min, precision, sec);



     The format can contain either numbered  argument  specifica-
     tions (that is, %n$ and *m$), or unnumbered argument specif-
     ications (that is, % and *), but normally not both. The only
     exception to this is that %% can be mixed with the %n$ form.
     The results  of  mixing  numbered  and  unnumbered  argument
     specifications  in  a format string are undefined. When num-
     bered argument specifications are used, specifying  the  Nth
     argument  requires  that all the leading arguments, from the
     first to the (N-1)th, are specified in the format string.

  Flag Characters
     The flag characters and their meanings are:

     `
              The integer portion of  the  result  of  a  decimal
              conversion  (%i, %d, %u, %f, %F, %g, or %G) will be
              formatted with thousands' grouping characters.  For
              other  conversions  the  behavior is undefined. The
              non-monetary grouping character is used.


     -
              The result of the conversion will be left-justified
              within  the  field.  The  conversion will be right-
              justified if this flag is not specified.


     +
              The result of a signed conversion will always begin
              with  a  sign  (+  or -). The conversion will begin
              with a sign only when a negative value is converted
              if this flag is not specified.


     space
              If the first character of a  signed  conversion  is
              not  a sign or if a signed conversion results in no
              characters, a  space  will  be  placed  before  the
              result.  This  means  that if the space and + flags
              both appear, the space flag will be ignored.


     #
              The value is to be converted to an alternate  form.
              For  c, d, i, s, and u conversions, the flag has no
              effect. For an o conversion, it increases the  pre-
              cision  (if  necessary) to force the first digit of
              the result to be a zero. For x or X  conversion,  a
              non-zero  result  will have 0x (or 0X) prepended to
              it. For a, A, e, E, f, F, g, and G conversions, the
              result  will always contain a radix character, even
              if no digits follow the  radix  character.  Without
              this  flag,  the  radix  character  appears  in the
              result of these conversions only if a digit follows
              it.  For  g  and G conversions, trailing zeros will
              not be removed from the  result  as  they  normally
              are.


     0
              For d, i, o, u, x, X, a, A, e, E, f, F,  g,  and  G
              conversions,  leading  zeros (following any indica-
              tion of sign or base) are used to pad to the  field
              width;  no space padding 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.
              If  the  0  and  `  flags both appear, the grouping
              characters are inserted before  zero  padding.  For
              other conversions, the behavior is undefined.


  Length Modifiers
     The length modifiers and their meanings are:

     hh
                     Specifies that a following d, i, o, u, x, or
                     X  conversion  specifier applies to a signed
                     char or unsigned char argument (the argument
                     will  have  been  promoted  according to the
                     integer promotions, but its  value  will  be
                     converted  to  signed  char or unsigned char
                     before printing);  or  that  a  following  n
                     conversion specifier applies to a pointer to
                     a signed char argument.


     h
                     Specifies that a following d, i, o, u, x, or
                     X conversion specifier applies to a short or
                     unsigned short argument (the  argument  will
                     have  been promoted according to the integer
                     promotions, but its value will be  converted
                     to short or unsigned short before printing);
                     or that a following n  conversion  specifier
                     applies to a pointer to a short argument.


     l (ell)
                     Specifies that a following d, i, o, u, x, or
                     X  conversion specifier applies to a long or
                     unsigned long argument; that a  following  n
                     conversion specifier applies to a pointer to
                     a long argument; that a following c  conver-
                     sion specifier applies to a wint_t argument;
                     that  a  following  s  conversion  specifier
                     applies  to a pointer to a wchar_t argument;
                     or has no effect on a following a, A, e,  E,
                     f, F, g, or G conversion specifier.


     ll (ell-ell)
                     Specifies that a following d, i, o, u, x, or
                     X  conversion  specifier  applies  to a long
                     long or unsigned long long argument; or that
                     a  following  n conversion specifier applies
                     to a pointer to a long long argument.


     j
                     Specifies that a following d, i, o, u, x, or
                     X   conversion   specifier   applies  to  an
                     intmax_t or uintmax_t argument;  or  that  a
                     following  n conversion specifier applies to
                     a  pointer  to  an  intmax_t  argument.  See
                     NOTES.


     z
                     Specifies that a following d, i, o, u, x, or
                     X  conversion  specifier applies to a size_t
                     or the  corresponding  signed  integer  type
                     argument;  or  that a following n conversion
                     specifier applies to a pointer to  a  signed
                     integer  type  corresponding to size_t argu-
                     ment.


     t
                     Specifies that a following d, i, o, u, x, or
                     X   conversion   specifier   applies   to  a
                     ptrdiff_t or the corresponding unsigned type
                     argument;  or  that a following n conversion
                     specifier  applies  to  a   pointer   to   a
                     ptrdiff_t argument.


     L
                     Specifies that a following a, A, e, E, f, F,
                     g,  or  G  conversion specifier applies to a
                     long double argument.



     If a length modifier appears with any  conversion  specifier
     other than as specified above, the behavior is undefined.

  Conversion Specifiers
     Each conversion specifier results in fetching zero  or  more
     arguments.  The  results are undefined if there are insuffi-
     cient arguments for the format. If the format  is  exhausted
     while arguments remain, the excess arguments are ignored.


     The conversion specifiers and their meanings are:

     d, i
             The int argument is converted to a signed decimal in
             the  style  [-]dddd.  The  precision  specifies  the
             minimum number of digits to  appear;  if  the  value
             being  converted can be represented in fewer digits,
             it will be expanded with leading zeros. The  default
             precision  is  1. The result of converting 0 with an
             explicit precision of 0 is no characters.


     o
             The unsigned int argument is converted  to  unsigned
             octal format in the style dddd. The precision speci-
             fies the minimum number of digits to appear; if  the
             value  being  converted  can be represented in fewer
             digits, it will be expanded with leading zeros.  The
             default  precision  is 1. The result of converting 0
             with an explicit precision of 0 is no characters.


     u
             The unsigned int argument is converted  to  unsigned
             decimal  format  in  the  style  dddd. The precision
             specifies the minimum number of digits to appear; if
             the  value  being  converted  can  be represented in
             fewer digits,  it  will  be  expanded  with  leading
             zeros.  The  default  precision  is 1. The result of
             converting 0 with an explicit precision of 0  is  no
             characters.


     x
             The unsigned int argument is converted  to  unsigned
             hexadecimal  format  in  the style dddd; the letters
             abcdef are used. The precision specifies the minimum
             number  of digits to appear; if the value being con-
             verted can be represented in fewer digits,  it  will
             be  expanded  with leading zeros. The default preci-
             sion is 1. The result of converting 0 with an expli-
             cit precision of 0 is no characters.


     X
             Behaves the  same  as  the  x  conversion  specifier
             except  that  letters  ABCDEF  are  used  instead of
             abcdef.


     f, F
             The double argument is converted to decimal notation
             in  the style [-]ddd.ddd, where the number of digits
             after the radix  character  (see  setlocale(3C))  is
             equal  to the precision specification. If the preci-
             sion is missing it is taken as 6; if  the  precision
             is  explicitly 0 and the # flag is not specified, no
             radix  character  appears.  If  a  radix   character
             appears,  at  least  1  digit appears before it. The
             converted value is rounded to fit the specified out-
             put  format  according  to  the  prevailing floating
             point rounding direction mode. If the conversion  is
             not exact, an inexact exception is raised.

             For the f specifier, a double argument  representing
             an  infinity or NaN is converted in the style of the
             e conversion specifier, except that for an  infinite
             argument,  "infinity"  or "Infinity" is printed when
             the precision is at least 8 and "inf"  or  "Inf"  is
             printed otherwise.

             For the F specifier, a double argument  representing
             an  infinity  or NaN is converted in the SUSv3 style
             of the E conversion specifier, except  that  for  an
             infinite  argument,  "INFINITY"  is printed when the
             precision is at least 8 and or "INF" is printed oth-
             erwise.


     e, E
             The  double  argument  is  converted  to  the  style
             [-]d.ddde+-dd,  where  there  is one digit before the
             radix character (which is non-zero if  the  argument
             is  non-zero)  and  the number of digits after it is
             equal to the precision. When the precision is  miss-
             ing  it is taken as 6; if the precision is 0 and the
             # flag is not specified, no radix character appears.
             The  E  conversion  specifier  will produce a number
             with E instead of e introducing  the  exponent.  The
             exponent  always  contains  at least two digits. The
             converted value is rounded to fit the specified out-
             put  format  according  to  the  prevailing floating
             point rounding direction mode. If the conversion  is
             not exact, an inexact exception is raised.

             Infinity and NaN values are handled in  one  of  the
             following ways:

             SUSv3
                        For the e specifier,  a  double  argument
                        representing  an  infinity  is printed as
                        "[-]infinity", when the precision for the
                        conversion  is at least 7 and as "[-]inf"
                        otherwise. A double argument representing
                        a  NaN  is printed as "[-]nan". For the E
                        specifier, "INF", "INFINITY",  and  "NAN"
                        are printed instead of "inf", "infinity",
                        and "nan", respectively. Printing of  the
                        sign follows the rules described above.


             Default
                        A double argument representing an  infin-
                        ity is printed as "[-]Infinity", when the
                        precision for the conversion is at  least
                        7  and  as  "[-]Inf"  otherwise. A double
                        argument representing a NaN is printed as
                        "[-]NaN".  Printing  of  the sign follows
                        the rules described above.



     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 signifi-
             cant  digits.  If  an explicit precision is 0, it is
             taken as 1. The style  used  depends  on  the  value
             converted:  style  e (or E) will be used only if the
             exponent resulting from the conversion is less  than
             -4 or greater than or equal to the precision. Trail-
             ing zeros are removed from the  fractional  part  of
             the  result. A radix character appears only if it is
             followed by a digit.

             A double argument representing an infinity or NaN is
             converted  in  the  style  of  the e or E conversion
             specifier, except that  for  an  infinite  argument,
             "infinity",  "INFINITY",  or  "Infinity"  is printed
             when the precision is at least 8 and  "inf",  "INF",
             or "Inf" is printed otherwise.


     a, A
             A  double  argument  representing  a  floating-point
             number  is  converted in the style "[-]0xh.hhhhp+-d",
             where the single  hexadecimal  digit  preceding  the
             radix  point is 0 if the value converted is zero and
             1 otherwise and the  number  of  hexadecimal  digits
             after it is equal to the precision; if the precision
             is missing, the number of digits printed  after  the
             radix  point  is  13  for the conversion of a double
             value, 16 for the conversion of a long double  value
             on  x86,  and 28 for the conversion of a long double
             value on SPARC; if the precision is zero and the `#'
             flag  is  not  specified, no decimal-point character
             will appear. The letters "abcdef"  are  used  for  a
             conversion  and  the  letters "ABCDEF" for A conver-
             sion. The A conversion specifier produces  a  number
             with  `X'  and  `P'  instead  of  `x'  and  `p'. The
             exponent will always contain at least one digit, and
             only  as  many more digits as necessary to represent
             the decimal exponent of 2. If the value is zero, the
             exponent is zero.

             The converted value is rounded to fit the  specified
             output  format  according to the prevailing floating
             point rounding direction mode. If the conversion  is
             not exact, an inexact exception is raised.

             A double argument representing an infinity or NaN is
             converted in the SUSv3 style of an e or E conversion
             specifier.


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

             If an l (ell) qualifier is present, the wint_t argu-
             ment is converted as if by an ls conversion specifi-
             cation with no precision and an argument that points
             to  a  two-element  array of type wchar_t, the first
             element of which contains the wint_t argument to the
             ls  conversion  specification and the second element
             contains a null wide-character.


     C
             Same as lc.


     wc
             The int argument is converted to  a  wide  character
             (wchar_t),  and  the  resulting  wide  character  is
             printed.


     s
             The argument must be a pointer to an array of  char.
             Bytes  from  the  array  are  written up to (but not
             including) any terminating null byte. If a precision
             is specified, a standard-conforming application (see
             standards(5)) will write only the  number  of  bytes
             specified  by  precision; an application that is not
             standard-conforming will write only the  portion  of
             the  string  that  will  display  in  the  number of
             columns of screen display specified by precision. If
             the  precision  is  not specified, it is taken to be
             infinite, so all bytes up to the first null byte are
             printed.  An  argument  with a null value will yield
             undefined results.

             If an l (ell) qualifier  is  present,  the  argument
             must  be  a  pointer  to  an  array of type wchar_t.
             Wide-characters from  the  array  are  converted  to
             characters  (each as if by a call to the wcrtomb(3C)
             function, with the conversion state described by  an
             mbstate_t  object  initialized  to  zero  before the
             first wide-character is converted) up to and includ-
             ing a terminating null wide-character. The resulting
             characters are written up to (but not including) the
             terminating  null  character (byte). If no precision
             is specified, the array must contain  a  null  wide-
             character. If a precision is specified, no more than
             that many characters (bytes) are written  (including
             shift sequences, if any), and the array must contain
             a null wide-character if,  to  equal  the  character
             sequence length given by the precision, the function
             would need to access a wide-character one  past  the
             end  of the array. In no case is a partial character
             written.


     S
             Same as ls.

     ws
             The argument must  be  a  pointer  to  an  array  of
             wchar_t. Bytes from the array are written up to (but
             not including) any terminating  null  character.  If
             the precision is specified, only that portion of the
             wide-character array that will display in the number
             of  columns of screen display specified by precision
             will be written. If the precision is not  specified,
             it  is  taken to be infinite, so all wide characters
             up to the first null character are printed. An argu-
             ment with a null value will yield undefined results.


     p
             The argument must be a pointer to void. The value of
             the  pointer  is  converted to a set of sequences of
             printable characters, which should be  the  same  as
             the  set  of  sequences  that  are matched by the %p
             conversion of the scanf(3C) function.


     n
             The argument must be a pointer to  an  integer  into
             which  is written the number of bytes written to the
             output standard I/O stream so far by  this  call  to
             one  of  the printf() functions. No argument is con-
             verted.


     %
             Print a %; no  argument  is  converted.  The  entire
             conversion specification must be %%.



     If a conversion specification does  not  match  one  of  the
     above forms, the behavior is undefined.


     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 simply expanded  to
     contain  the  conversion  result.  Characters  generated  by
     printf() and fprintf() are printed as if the putc(3C)  func-
     tion had been called.


     The st_ctime and st_mtime fields of the file will be  marked
     for  update  between  the  call to a successful execution of
     printf() or fprintf() and the next successful completion  of
     a  call  to fflush(3C) or fclose(3C) on the same stream or a
     call to exit(3C) or abort(3C).

Return Values
     The printf(), fprintf(), sprintf(), and asprintf() functions
     return  the  number  of  bytes  transmitted  (excluding  the
     terminating  null  byte  in  the  case  of   sprintf()   and
     asprintf()).


     The snprintf() function returns the  number  of  bytes  that
     would  have  been  written  to  s if n had been sufficiently
     large (excluding the terminating null byte.) If the value of
     n  is 0 on a call to snprintf(), s can be a null pointer and
     the number of bytes that would have been written  if  n  had
     been  sufficiently  large  (excluding  the  terminating null
     byte) is returned.


     Each function returns a negative value if  an  output  error
     was encountered.

Errors
     For the conditions under which printf() and  fprintf()  will
     fail and may fail, refer to fputc(3C) or fputwc(3C).


     The snprintf() function will fail if:

     EOVERFLOW
                  The value of n is greater than INT_MAX  or  the
                  number  of  bytes  needed  to  hold  the output
                  excluding the terminating null is greater  than
                  INT_MAX.



     The printf(), fprintf(), sprintf(), and snprintf() functions
     may fail if:

     EILSEQ
               A wide-character code that does not correspond  to
               a valid character has been detected.


     EINVAL
               There are insufficient arguments.



     The printf(), fprintf(), and asprintf() functions  may  fail
     due to an underlying malloc(3C) failure if:

     EAGAIN
               Storage space is temporarily unavailable.


     ENOMEM
               Insufficient storage space is available.

Usage

     If the application calling the printf()  functions  has  any
     objects  of type wint_t or wchar_t, it must also include the
     header <wchar.h> to have these objects defined.

  Escape Character Sequences
     It is common to use the  following  escape  sequences  built
     into  the  C  language  when entering format strings for the
     printf() functions, but these sequences are processed by the
     C compiler, not by the printf() function.

     \a
            Alert. Ring the bell.


     \b
            Backspace. Move the printing position to one  charac-
            ter  before  the current position, unless the current
            position is the start of a line.


     \f
            Form feed. Move the printing position to the  initial
            printing position of the next logical page.


     \n
            Newline. Move the printing position to the  start  of
            the next line.


     \r
            Carriage return. Move the printing  position  to  the
            start of the current line.


     \t
            Horizontal tab. Move the  printing  position  to  the
            next  implementation-defined  horizontal tab position
            on the current line.


     \v
            Vertical tab. Move the printing position to the start
            of the next implementation-defined vertical tab posi-
            tion.



     In addition, the C language supports character sequences  of
     the form


     \octal-number


     and
     \hex-number


     which translates into the character represented by the octal
     or hexadecimal number. For example, if ASCII representations
     are being used, the letter `a' may be written as `\141'  and
     `Z'  as  `\132'.  This  syntax  is  most  frequently used to
     represent the  null  character  as  `\0'.  This  is  exactly
     equivalent  to  the numeric constant zero (0). Note that the
     octal number does not include the zero prefix  as  it  would
     for  a  normal  octal  constant.  To  specify  a hexadecimal
     number, omit the zero so that the prefix is an  `x'  (upper-
     case  `X' is not allowed in this context). Support for hexa-
     decimal sequences is an ANSI extension. See standards(5).

Examples
     Example 1 To print the language-independent  date  and  time
     format, the following statement could be used:

       printf (format, weekday, month, day, hour, min);



     For American usage, format could be a pointer to the string:


       "%s, %s %d, %d:%.2d\n"



     producing the message:


       Sunday, July 3, 10:02



     whereas for German usage, format could be a pointer  to  the
     string:


       "%1$s, %3$d. %2$s, %4$d:%5$.2d\n"



     producing the message:


       Sonntag, 3. Juli, 10:02

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


     Example 3 To print pi to 5 decimal places:

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


     Example 4 The following example applies only to applications
     that  are  not standard-conforming. To print a list of names
     in columns which are 20 characters wide:

       printf("%20s%20s%20s", lastname, firstname, middlename);

Attributes
     See attributes(5) for descriptions of the  following  attri-
     butes:



     tab() box; lw(2.75i) |lw(2.75i) lw(2.75i) |lw(2.75i)  ATTRI-
     BUTE   TYPEATTRIBUTE   VALUE   _   CSIEnabled   _  Interface
     StabilityCommitted  _  MT-LevelSee  below.   _   StandardSee
     below.



     All of these functions can be used safely  in  multithreaded
     applications,  as  long as setlocale(3C) is not being called
     to change the locale. The sprintf() and snprintf() functions
     are Async-Signal-Safe.


     See standards(5) for the standards conformance of  printf(),
     fprintf(),  sprintf(),  and snprintf(). The asprintf() func-
     tion is modeled on the one  that  appears  in  the  FreeBSD,
     NetBSD, and GNU C libraries.

See Also
     exit(2), lseek(2), write(2), abort(3C), ecvt(3C),  exit(3C),
     fclose(3C),  fflush(3C),  fputwc(3C),  free(3C), malloc(3C),
     putc(3C), scanf(3C), setlocale(3C), stdio(3C),  vprintf(3C),
     wcstombs(3C),  wctomb(3C),  attributes(5), environ(5), standards(5)

Notes

     If the j length modifier is used, 32-bit  applications  that
     were compiled using c89 on releases prior to Solaris 10 will
     experience undefined behavior.


     The snprintf() return value when n = 0 was  changed  in  the
     Solaris  10  release.  The  change  was  based  on the SUSv3
     specification. The previous behavior was based on  the  ini-
     tial  SUSv2  specification,  where  snprintf()  when  n  = 0
     returns an unspecified value less than 1.
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 1.0 CSS3