25 Localization library [localization]

locale loc = str.getloc();

• (2.1)
  Stage 1: Determine a printf conversion specifier spec and determine the characters that would be printed by printf ([c.files]) given this conversion specifier for

  printf(spec, val)

  assuming that the current locale is the "C" locale.
• (2.2)
  Stage 2: Adjust the representation by converting each char determined by stage 1 to a charT using a conversion and values returned by members of use_­facet<numpunct<charT>>(str.getloc())
• (2.3)
  Stage 3: Determine where padding is required.
• (2.4)
  Stage 4: Insert the sequence into the out.

• (5.1)
  Stage 1: The first action of stage 1 is to determine a conversion specifier.
  The tables that describe this determination use the following local variables

  fmtflags flags = str.flags();
  fmtflags basefield =  (flags & (ios_base::basefield));
  fmtflags uppercase =  (flags & (ios_base::uppercase));
  fmtflags floatfield = (flags & (ios_base::floatfield));
  fmtflags showpos =    (flags & (ios_base::showpos));
  fmtflags showbase =   (flags & (ios_base::showbase));
  fmtflags showpoint =  (flags & (ios_base::showpoint));

  All tables used in describing stage 1 are ordered.
  That is, the first line whose condition is true applies.
  A line without a condition is the default behavior when none of the earlier lines apply.
  For conversion from an integral type other than a character type, the function determines the integral conversion specifier as indicated in Table 70.
  Table 70 — Integer conversions
  

  State	stdio equivalent
  basefield == ios_­base​::​oct	%o
  (basefield == ios_­base​::​hex) && !uppercase	%x
  (basefield == ios_­base​::​hex)	%X
  for a signed integral type	%d
  for an unsigned integral type	%u

  For conversion from a floating-point type, the function determines the floating-point conversion specifier as indicated in Table 71.
  Table 71 — Floating-point conversions
  

  State	stdio equivalent
  floatfield == ios_­base​::​fixed	%f
  floatfield == ios_­base​::​scientific && !uppercase	%e
  floatfield == ios_­base​::​scientific	%E
  floatfield == (ios_­base​::​fixed | ios_­base​::​scientific) && !uppercase	%a
  floatfield == (ios_­base​::​fixed | ios_­base​::​scientific)	%A
  !uppercase	%g
  otherwise	%G

  For conversions from an integral or floating-point type a length modifier is added to the conversion specifier as indicated in Table 72.
  Table 72 — Length modifier
  

  Type	Length modifier
  long	l
  long long	ll
  unsigned long	l
  unsigned long long	ll
  long double	L
  otherwise	none

  The conversion specifier has the following optional additional qualifiers prepended as indicated in Table 73.
  Table 73 — Numeric conversions
  

  Type(s)	State	stdio equivalent
  an integral type	showpos	+
  	showbase	#
  a floating-point type	showpos	+
  	showpoint	#

  For conversion from a floating-point type, if floatfield != (ios_­base​::​fixed | ios_­base​::​​scientific), str.precision() is specified as precision in the conversion specification.
  Otherwise, no precision is specified.
  For conversion from void* the specifier is %p.
  The representations at the end of stage 1 consists of the char's that would be printed by a call of printf(s, val) where s is the conversion specifier determined above.
• (5.2)
  Stage 2: Any character c other than a decimal point(.) is converted to a charT via use_­facet<ctype<charT>>(loc).widen( c )
  A local variable punct is initialized via

  const numpunct<charT>& punct = use_facet<numpunct<charT>>(str.getloc());

  For arithmetic types, punct.thousands_­sep() characters are inserted into the sequence as determined by the value returned by punct.do_­grouping() using the method described in [facet.numpunct.virtuals]
  Decimal point characters(.) are replaced by punct.decimal_­point()
• (5.3)
  Stage 3: A local variable is initialized as

  fmtflags adjustfield = (flags & (ios_base::adjustfield));

  The location of any padding240 is determined according to Table 74.
  Table 74 — Fill padding
  

  State	Location
  adjustfield == ios_­base​::​left	pad after
  adjustfield == ios_­base​::​right	pad before
  adjustfield == internal and a sign occurs in the representation	pad after the sign
  adjustfield == internal and representation after stage 1 began with 0x or 0X	pad after x or X
  otherwise	pad before

  If str.width() is nonzero and the number of charT's in the sequence after stage 2 is less than str.​width(), then enough fill characters are added to the sequence at the position indicated for padding to bring the length of the sequence to str.width().
  str.width(0) is called.
• (5.4)
  Stage 4: The sequence of charT's at the end of stage 3 are output via

  *out++ = c

string_type s =
  val ? use_facet<numpunct<charT>>(loc).truename()
      : use_facet<numpunct<charT>>(loc).falsename();