www.gibmonks.com

Main Page




Previous Page
Next Page

[Page 787 (continued)]

15.7. Stream Format States and Stream Manipulators

Various stream manipulators can be used to specify the kinds of formatting to be performed during stream-I/O operations. Stream manipulators control the output's format settings. Figure 15.12 lists each stream manipulator that controls a given stream's format state. All these manipulators belong to class ios_base. We show examples of most of these stream manipulators in the next several sections.

Figure 15.12. Format state stream manipulators from <iostream>.

[Page 788]

Stream Manipulator

Description

skipws

Skip white-space characters on an input stream. This setting is reset with stream manipulator noskipws.

left

Left justify output in a field. Padding characters appear to the right if necessary.

right

Right justify output in a field. Padding characters appear to the left if necessary.

internal

Indicate that a number's sign should be left justified in a field and a number's magnitude should be right justified in that same field (i.e., padding characters appear between the sign and the number).

dec

Specify that integers should be treated as decimal (base 10) values.

oct

Specify that integers should be treated as octal (base 8) values.

hex

Specify that integers should be treated as hexadecimal (base 16) values.

showbase

Specify that the base of a number is to be output ahead of the number (a leading 0 for octals; a leading 0x or 0X for hexadecimals). This setting is reset with stream manipulator noshowbase.

showpoint

Specify that floating-point numbers should be output with a decimal point. This is used normally with fixed to guarantee a certain number of digits to the right of the decimal point, even if they are zeros. This setting is reset with stream manipulator noshowpoint.

uppercase

Specify that uppercase letters (i.e., X and A tHRough F) should be used in a hexadecimal integer and that uppercase E should be used when representing a floating-point value in scientific notation. This setting is reset with stream manipulator nouppercase.

showpos

Specify that positive numbers should be preceded by a plus sign (+). This setting is reset with stream manipulator noshowpos.

scientific

Specify output of a floating-point value in scientific notation.

fixed

Specify output of a floating-point value in fixed-point notation with a specific number of digits to the right of the decimal point.



[Page 788]

15.7.1. Trailing Zeros and Decimal Points (showpoint)

Stream manipulator showpoint forces a floating-point number to be output with its decimal point and trailing zeros. For example, the floating-point value 79.0 prints as 79 without using showpoint and prints as 79.000000 (or as many trailing zeros as are specified by the current precision) using showpoint. To reset the showpoint setting, output the stream manipulator noshowpoint. The program in Fig. 15.13 shows how to use stream manipulator showpoint to control the printing of trailing zeros and decimal points for floating-point values. Recall that the default precision of a floating-point number is 6. When neither the fixed nor the scientific stream manipulator is used, the precision represents the number of significant digits to display (i.e., the total number of digits to display), not the number of digits to display after decimal point.

Figure 15.13. Controlling the printing of trailing zeros and decimal points in floating-point values.
(This item is displayed on pages 788 - 789 in the print version)

 1  // Fig. 15.13: Fig15_13.cpp
 2  // Using showpoint to control the printing of
 3  // trailing zeros and decimal points for doubles.
 4  #include <iostream>
 5  using std::cout;
 6  using std::endl;
 7  using std::showpoint;
 8
 9  int main()
10  {
11     // display double values with default stream format
12     cout << "Before using showpoint" << endl
13        << "9.9900 prints as: " << 9.9900 << endl
14        << "9.9000 prints as: " << 9.9000 << endl
15        << "9.0000 prints as: " << 9.0000 << endl << endl;
16
17     // display double value after showpoint
18     cout << showpoint
19        << "After using showpoint" << endl
20        << "9.9900 prints as: " << 9.9900 << endl
21        << "9.9000 prints as: " << 9.9000 << endl
22        << "9.0000 prints as: " << 9.0000 << endl;
23     return 0;
24  } // end main

 Before using showpoint
 9.9900 prints as: 9.99
 9.9000 prints as: 9.9
 9.0000 prints as: 9

 After using showpoint
 9.9900 prints as: 9.99000
 9.9000 prints as: 9.90000
 9.0000 prints as: 9.00000



[Page 789]

15.7.2. Justification (left, right and internal)

Stream manipulators left and right enable fields to be left justified with padding characters to the right or right justified with padding characters to the left, respectively. The padding character is specified by the fill member function or the setfill parameterized stream manipulator (which we discuss in Section 15.7.3). Figure 15.14 uses the setw, left and right manipulators to left justify and right justify integer data in a field.

Figure 15.14. Left justification and right justification with stream manipulators left and right.
(This item is displayed on pages 789 - 790 in the print version)

 1  // Fig. 15.14: Fig15_14.cpp
 2  // Demonstrating left justification and right justification.
 3  #include <iostream>
 4  using std::cout;
 5  using std::endl;
 6  using std::left; 
 7  using std::right;
 8
 9  #include <iomanip>
10  using std::setw;
11
12  int main()
13  {
14     int x = 12345;
15
16     // display x right justified (default)
17     cout << "Default is right justified:" << endl
18        << setw( 10 ) << x;
19
20     // use left manipulator to display x left justified
21     cout << "\n\nUse std::left to left justify x:\n"
22        << left << setw( 10 ) << x;
23
24     // use right manipulator to display x right justified
25     cout << "\n\nUse std::right to right justify x:\n"
26        << right << setw( 10 ) << x << endl;
27     return 0;
28  } // end main

 Default is right justified:
      12345

 Use std::left to left justify x:
 12345

 Use std::right to right justify x:
      12345



[Page 790]

Stream manipulator internal indicates that a number's sign (or base when using stream manipulator showbase) should be left justified within a field, that the number's magnitude should be right justified and that intervening spaces should be padded with the fill character. Figure 15.15 shows the internal stream manipulator specifying internal spacing (line 15). Note that showpos forces the plus sign to print (line 15). To reset the showpos setting, output the stream manipulator noshowpos.

Figure 15.15. Printing an integer with internal spacing and plus sign.
(This item is displayed on pages 790 - 791 in the print version)

 1  // Fig. 15.15: Fig15_15.cpp
 2  // Printing an integer with internal spacing and plus sign.
 3  #include <iostream>
 4  using std::cout;
 5  using std::endl;
 6  using std::internal;
 7  using std::showpos; 
 8 
 9  #include <iomanip>
10  using std::setw;
11 
12  int main()
13  {
14     // display value with internal spacing and plus sign
15     cout << internal << showpos << setw( 10 ) << 123 << endl;
16     return 0;
17  } // end main

 +      123



[Page 791]

15.7.3. Padding (fill, setfill)

The fill member function specifies the fill character to be used with justified fields; if no value is specified, spaces are used for padding. The fill function returns the prior padding character. The setfill manipulator also sets the padding character. Figure 15.16 demonstrates using member function fill (line 40) and stream manipulator setfill (lines 44 and 47) to set the fill character.

Figure 15.16. Using member function fill and stream manipulator setfill to change the padding character for fields larger than the values being printed.
(This item is displayed on pages 791 - 792 in the print version)

 1  // Fig. 15.16: Fig15_16.cpp
 2  // Using member function fill and stream manipulator setfill to change
 3  // the padding character for fields larger than the printed value.
 4  #include <iostream>
 5  using std::cout;
 6  using std::dec;
 7  using std::endl;
 8  using std::hex;
 9  using std::internal;
10  using std::left;
11  using std::right;
12  using std::showbase;
13
14  #include <iomanip>
15  using std::setfill;
16  using std::setw;
17
18  int main()
19  {
20     int x = 10000;
21
22     // display x
23     cout << x << " printed as int right and left justified\n"
24        << "and as hex with internal justification.\n"
25        << "Using the default pad character (space):" << endl;
26
27     // display x with base
28     cout << showbase << setw( 10 ) << x << endl;
29
30     // display x with left justification
31     cout << left << setw( 10 ) << x << endl;
32
33     // display x as hex with internal justification
34     cout << internal << setw( 10 ) << hex << x << endl << endl;
35
36     cout << "Using various padding characters:" << endl;
37
38     // display x using padded characters (right justification)
39     cout << right;
40     cout.fill( '*' );
41     cout << setw( 10 ) << dec << x << endl;
42
43     // display x using padded characters (left justification)
44     cout << left << setw( 10 ) << setfill( '%' ) << x << endl;
45
46     // display x using padded characters (internal justification)
47     cout << internal << setw( 10 ) << setfill( '^' ) << hex
48        << x << endl;
49     return 0;
50  } // end main

 10000 printed as int right and left justified
 and as hex with internal justification.
 Using the default pad character (space):
      10000
 10000
 0x    2710

 Using various padding characters:
 *****10000
 10000%%%%%
 0x^^^^2710



[Page 792]

15.7.4. Integral Stream Base (dec, oct, hex, showbase)

C++ provides stream manipulators dec, hex and oct to specify that integers are to be displayed as decimal, hexadecimal and octal values, respectively. Stream insertions default to decimal if none of these manipulators is used. With stream extraction, integers prefixed with 0 (zero) are treated as octal values, integers prefixed with 0x or 0X are treated as hexadecimal values, and all other integers are treated as decimal values. Once a particular base is specified for a stream, all integers on that stream are processed using that base until a different base is specified or until the program terminates.

Stream manipulator showbase forces the base of an integral value to be output. Decimal numbers are output by default, octal numbers are output with a leading 0, and hexadecimal numbers are output with either a leading 0x or a leading 0X (as we discuss in Section 15.7.6, stream manipulator uppercase determines which option is chosen). Figure 15.17 demonstrates the use of stream manipulator showbase to force an integer to print in decimal, octal and hexadecimal formats. To reset the showbase setting, output the stream manipulator noshowbase.


[Page 793]
Figure 15.17. Stream manipulator showbase.

 1  // Fig. 15.17: Fig15_17.cpp
 2  // Using stream manipulator showbase.
 3  #include <iostream>
 4  using std::cout;
 5  using std::endl;
 6  using std::hex;
 7  using std::oct;
 8  using std::showbase;
 9
10  int main()
11  {
12     int x = 100;
13
14     // use showbase to show number base
15     cout << "Printing integers preceded by their base:" << endl
16        << showbase;
17
18     cout << x << endl; // print decimal value
19     cout << oct << x << endl; // print octal value
20     cout << hex << x << endl; // print hexadecimal value
21     return 0;
22  } // end main

 Printing integers preceded by their base:
 100
 0144
 0x64


15.7.5. Floating-Point Numbers; Scientific and Fixed Notation (scientific, fixed)

Stream manipulators scientific and fixed control the output format of floating-point numbers. Stream manipulator scientific forces the output of a floating-point number to display in scientific format. Stream manipulator fixed forces a floating-point number to display a specific number of digits (as specified by member function precision or stream manipulator setprecision) to the right of the decimal point. Without using another manipulator, the floating-point-number value determines the output format.

Figure 15.18 demonstrates displaying floating-point numbers in fixed and scientific formats using stream manipulators scientific (line 21) and fixed (line 25). The exponent format in scientific notation might differ across different compilers.

Figure 15.18. Floating-point values displayed in default, scientific and fixed formats.
(This item is displayed on page 794 in the print version)

 1  // Fig. 15.18: Fig15_18.cpp
 2  // Displaying floating-point values in system default,
 3  // scientific and fixed formats.
 4  #include <iostream>
 5  using std::cout;
 6  using std::endl;
 7  using std::fixed;     
 8  using std::scientific;
 9
10  int main()
11  {
12     double x = 0.001234567;
13     double y = 1.946e9;
14
15     // display x and y in default format
16     cout << "Displayed in default format:" << endl
17        << x << '\t' << y << endl;
18
19     // display x and y in scientific format
20     cout << "\nDisplayed in scientific format:" << endl
21        << scientific << x << '\t' << y << endl;
22
23     // display x and y in fixed format
24     cout << "\nDisplayed in fixed format:" << endl
25        << fixed << x << '\t' << y << endl;
26     return 0;
27  } // end main

 Displayed in default format:
 0.00123457      1.946e+009

 Displayed in scientific format:
 1.234567e-003   1.946000e+009

 Displayed in fixed format:
 0.001235        1946000000.000000


15.7.6. Uppercase/Lowercase Control (uppercase)

Stream manipulator uppercase outputs an uppercase X or E with hexadecimal-integer values or with scientific-notation floating-point values, respectively (Fig. 15.19). Using stream manipulator uppercase also causes all letters in a hexadecimal value to be uppercase. By default, the letters for hexadecimal values and the exponents in scientific-notation floating-point values appear in lowercase. To reset the uppercase setting, output the stream-manipulator nouppercase.


[Page 794]
Figure 15.19. Stream manipulator uppercase.
(This item is displayed on pages 794 - 795 in the print version)

 1  // Fig. 15.19: Fig15_19.cpp
 2  // Stream manipulator uppercase.
 3  #include <iostream>
 4  using std::cout;
 5  using std::endl;
 6  using std::hex;
 7  using std::showbase;
 8  using std::uppercase;
 9 
10  int main()
11  {
12     cout << "Printing uppercase letters in scientific" << endl
13        << "notation exponents and hexadecimal values:" << endl;
14 
15     // use std:uppercase to display uppercase letters; use std::hex and
16     // std::showbase to display hexadecimal value and its base
17     cout << uppercase << 4.345e10 << endl
18        << hex << showbase << 123456789 << endl;
19     return 0;
20  } // end main

 Printing uppercase letters in scientific
 notation exponents and hexadecimal values:
 4.345E+010
 0X75BCD15



[Page 795]

15.7.7. Specifying Boolean Format (boolalpha)

C++ provides data type bool, whose values may be false or TRue, as a preferred alternative to the old style of using 0 to indicate false and nonzero to indicate TRue. A bool variable outputs as 0 or 1 by default. However, we can use stream manipulator boolalpha to set the output stream to display bool values as the strings "TRue" and "false". Use stream manipulator noboolalpha to set the output stream to display bool values as integers (i.e., the default setting). The program of Fig. 15.20 demonstrates these stream manipulators. Line 14 displays the bool value, which line 11 sets to true, as an integer. Line 18 uses manipulator boolalpha to display the bool value as a string. Lines 2122 then change the bool's value and use manipulator noboolalpha, so line 25 can display the bool value as an integer. Line 29 uses manipulator boolalpha to display the bool value as a string. Both boolalpha and noboolalpha are "sticky" settings.

Figure 15.20. Stream manipulators boolalpha and noboolalpha.
(This item is displayed on pages 795 - 796 in the print version)

 1  // Fig. 15.20: Fig15_20.cpp
 2  // Demonstrating stream manipulators boolalpha and noboolalpha.
 3  #include <iostream>
 4  using std::boolalpha;
 5  using std::cout;
 6  using std::endl;
 7  using std::noboolalpha;
 8
 9  int main()
10  {
11     bool booleanValue = true;
12
13     // display default true booleanValue
14     cout << "booleanValue is " << booleanValue << endl;
15
16     // display booleanValue after using boolalpha
17     cout << "booleanValue (after using boolalpha) is "
18        << boolalpha << booleanValue << endl << endl;
19
20     cout << "switch booleanValue and use noboolalpha" << endl;
21     booleanValue = false; // change booleanValue
22     cout << noboolalpha << endl; // use noboolalpha
23
24     // display default false booleanValue after using noboolalpha
25     cout << "booleanValue is " << booleanValue << endl;
26
27     // display booleanValue after using boolalpha again
28     cout << "booleanValue (after using boolalpha) is "
29        << boolalpha << booleanValue << endl;
30     return 0;
31  } // end main

 booleanValue is 1
 booleanValue (after using boolalpha) is true

 switch booleanValue and use noboolalpha

 booleanValue is 0
 booleanValue (after using boolalpha) is false


Good Programming Practice 15.1

Displaying bool values as true or false, rather than nonzero or 0, respectively, makes program outputs clearer.



[Page 796]

15.7.8. Setting and Resetting the Format State via Member Function flags

Throughout Section 15.7, we have been using stream manipulators to change output format characteristics. We now discuss how to return an output stream's format to its default state after having applied several manipulations. Member function flags without an argument returns the current format settings as a fmtflags data type (of class ios_base), which represents the format state. Member function flags with a fmtflags argument sets the format state as specified by the argument and returns the prior state settings. The initial settings of the value that flags returns might differ across several systems. The program of Fig. 15.21 uses member function flags to save the stream's original format state (line 22), then restore the original format settings (line 30).

Figure 15.21. flags member function.
(This item is displayed on pages 796 - 797 in the print version)

 1  // Fig. 15.21: Fig15_21.cpp
 2  // Demonstrating the flags member function.
 3  #include <iostream>
 4  using std::cout;
 5  using std::endl;
 6  using std::ios_base;
 7  using std::oct;
 8  using std::scientific;
 9  using std::showbase;
10
11  int main()
12  {
13     int integerValue = 1000;
14     double doubleValue = 0.0947628;
15
16     // display flags value, int and double values (original format)
17     cout << "The value of the flags variable is: " << cout.flags()
18        << "\nPrint int and double in original format:\n"
19        << integerValue << '\t' << doubleValue << endl << endl;
20
21     // use cout flags function to save original format     
22     ios_base::fmtflags originalFormat = cout.flags();      
23     cout << showbase << oct << scientific; // change format
24
25     // display flags value, int and double values (new format)
26     cout << "The value of the flags variable is: " << cout.flags()
27        << "\nPrint int and double in a new format:\n"
28        << integerValue << '\t' << doubleValue << endl << endl;
29
30     cout.flags( originalFormat ); // restore format
31
32     // display flags value, int and double values (original format)
33     cout << "The restored value of the flags variable is: "
34        << cout.flags()
35        << "\nPrint values in original format again:\n"
36        << integerValue << '\t' << doubleValue << endl;
37     return 0;
38  } // end main

 The value of the flags variable is: 513
 Print int and double in original format:
 1000    0.0947628

 The value of the flags variable is: 012011
 Print int and double in a new format:
 01750   9.476280e-002

 The restored value of the flags variable is: 513
 Print values in original format again:
 1000    0.0947628



Previous Page
Next Page