C++

IOS and Manipulator

Streams
A sequence of bytes
I/O moves them from/to secondary devices
I/O is extremely slow compared to processing speeds
C++ provides both formatted and unformatted I/O

2
IOstream Library Header files
We use the #include <iostream.h>
Contains basic infor required for all stream-I/O
operations
cin, cout, cerr, clog
#include <iomanip.h>
formatted I/O with parameterized stream manipulators
#include <fstream.h>
file processing operations

3
I/O File Class Hierarchy
Base Class Multiple inheritance

Input
ios
Output

istream ostream

iostream
iostream.h

fstream.h
ifstream fstream ofstream
File I/O
4
Unformatted I/O
Performed with read and write member functions
They take two parameters
an array of char or a buffer
a number which tells how many characters
cin.get(c);
cout.put(c);
cin.read(buffer,20);
cin.write (buffer,15);

5
getline Member Functions
cin.getline(array, size)
1 // Fig. 21.14: fig21_14.cpp
2 // Character input with member function
3 #include <iostream>
getline.
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 int main()
10{
11 const SIZE = 80;
12 char buffer[ SIZE ];
13
14 cout << "Enter a sentence:\n";
15 cin.getline( buffer, SIZE );
16
17 cout << "\nThe sentence entered is:\n" <<
18 return
buffer 0;
<< endl;
19}
Enter a sentence:
Using the getline member function
 
The sentence entered is:
Using iostream.h
Include iostream.h instead of stdio.h
Standard iostream objects:
cout - object providing a connection to the monitor
cin - object providing a connection to the keyboard
cerr - object providing a connection to error streem
To perform input and output we send messages to
one of these objects (or one that is connected to a
file)
The Insertion Operator (<<)
To send output to the screen we use the insertion
operator on the object cout
Format: cout << Expression;
The compiler figures out the type of the object and
prints it out appropriately
cout << 5; // Outputs 5
cout << 4.1; // Outputs 4.1
cout << “String”; // Outputs String
cout << ‘\n’; // Outputs a newline
Chaining Calls
Multiple uses of the insertion and extraction
operator can be chained together:
cout << E1 << E2 << E3 << … ;
cin >> V1 >> V2 >> V3 >> …;
Equivalent to performing the set of insertion or
extraction operators one at a time
Example
cout << “Total sales are $” << sales << ‘\n’;
cin >> Sales1 >> Sales2 >> Sales3;
FORMATTED CONSOLE I/O OPERATIONS
 C++ supports a number of features that
could be used for formatting the output. These
features include:
ios class functions and flags.
Manipulators.
User-defined output functions.
Function Task

To specify the required field size for displaying an output

Width() value.

precision() To specify the number of digits to be displayed after the

decimal point of a float value.

To specify a character that is used to fill the unused portion of

fill() a field.

To specify format flags that can control the form of output

setf()
display(such as left-justification and right-justification)

unsetf() To clear the flags specified.

Manipulators are special functions that can
be included in the I/O statements to alter the
format parameters of a stream.

To access manipulators, the file iomanip

should be included in the program.
Manipulators Equivalent ios function

setw() width()

setprecision() precision()

setfill() fill()

setiosflags() setf()

resetiosflags() unsetf()
 Defining Field Width: width ()

We can use the width() function to define the

width of a field necessary for the output of an
item.
cout.width (w);
Where w is the field width(number of
columns).
The field width should be specified for
each item separately.
For example,the statements
cout.width(5);
cout<<543<<12<<”\n”;
will produce the following output:

    5 4 3 1 2
 Setting Precision:precision()
By default ,the floating numbers are printed
with six digits after the decimal
point.However ,we can specify the number of
digits to be displayed after the decimal point
while printing the floating-point numbers.
This can be done by using the precision()
member function as follows:
cout.precision(d);
Where d is the number of digits to the
right of the decimal point.
Default precision is 6 digits.
For example ,the statements
cout.precision(3);
cout<<sqrt(2)<<”\n”;
cout<<3.14159<<”\n”;
cout<<2.50032<<”\n”;
will produce the following output:
1.141(truncated)
3.142(rounded to the nearest cent)
2.5(no trailing zeros)
 Filling and Padding :fill()

We can use the fill() function to fill the

unused positions by any desired character.It is
used in the following form:
cout.fill(ch);
Where ch represents the character which is
used for filling the unused positions.
 Example:
cout.fill(‘*’);
cout.width(10);
cout<<5250<<”\n”;
The output would be:

** * * * * 5 2 5 0

Financial institutions and banks use this kind of

padding while printing cheques so that no one can
change the amount easily.
 Formatting Flags,Bit-fields and setf()

The setf() function can be used as follows:

cout.setf(arg1,arg2);
The arg1 is one of the formatting flags
defined in the class ios. The formatting flag
specifies the format action required for the
output.
Another ios constant, arg2, known as bit
field specifies the group to which the formatting
flag belongs.
 Table shows the bit fields, flags and their format actions. There are
three bit fields and each has a group of format flags which are mutually
exclusive.

Format required Flag(arg1) Bit-Field(arg2)

Left-justified output ios::left ios::adjustfield
Right-justified output ios::right ios::adjustfield
Padding after sign or ios::internal ios::adjustfield
base
Indicater(like +##20)
Scientific notation ios::scientific ios::floatfield
Fixed point notation ios::fixed ios::floatfield
Decimal base ios::doc ios::basefield
Octal base ios::oct ios::basefield
Hexadecimal base ios::hex ios::basefield
Examples:
cout.setf(ios::left,ios::adjustfied);
cout.setf(ios::scientific,ios::floatfield);
Consider the following segment of code:
cout.filll(‘*’);
cout.setf(ios::left,ios::adjustfield);
cout.width(15);
cout<<”12345”<<”\n”;
This will produce the following output:

1 2 3 4 5 * * * * * * * * * *
The statements
cout.fill(‘*’);
cout.precision(3);
cout.setf(ios::internal,ios::adjustfield);
cout.setf(ios::scientific,ios::floatfield);
cout.width(15);
cout<<-12.34567<<”\n”;
will produce the following output:

- * * * * * 1 . 2 3 5 e + 0 1
 Displaying Trailing Zeros And Plus Sign
If we print the numbers 10.75, 25.00 and
15.50 using a field width of, say, eight
positions, with two digits precision, and then
the output will be as follows:

      1 0 . 7 5
            2 5
        1 5 . 5
 Certain situations, such as a list of prices of
items or the salary statement of employees,
require trailing zeros to be shown. The above
output would look better if they are printed as
follows:
10.75
25.00
15.50

The setf() can be used with the flag

ios::showpoint as a single argument to achieve this
form of output.
For example,
cout.setf(ios::showpoint);//display trailing
zeros
 Similarly, a plus sign can be printed before a
positive number using the following
statement:
cout.setf(ios::showpos);//show + sign
For example, the statements
cout.setf(ios::showpoint);
cout.setf(ios::showpos);
cout.precision(3);
cout.setf(ios::fixed,ios::floatfield);
cout.setf(ios::internal,ios::adjustfield);
cout.width(10);
cout<<275.5<<”\n”;
Will produce the following output:

+    2 7 5 . 5 0 0
 MANAGING OUTPUT WITH MANIPULATORS
The header file iomanip provides a set of functions
called manipulators which can be used to
manipulate the output formats.

Two or more manipulators can be used as a chain in

one statement as shown below:
cout<<manip1<<manip2<<manip3<<item;
cout<<manip1<<item1<<manip2<<item2;
 The most commonly used manipulators
are shown in table.
Manipulator Meaning Equivalent
setw(int w) Set the field width to w width()
setprecision(int d) Set the floating point precision()
precision to d.
setfill(int c) Set the fill character to c fill()
setiosflags(long f) Set the format flag f setf()
resetiosflags(long f) Clear the flag specified by f unsetf()
Endif Insert new line and flush “\n”
stream
 Some examples of manipulators are given
below:

cout<<setw(10)<<12345;

This statement prints the value 12345 right-

justified in a field width of 10 characters.
 The output can be made left-justified by
modifying the statement as follows:

cout<<setw(10)<<setiosflags(ios::left)<<12345;
One statement can be used to format output for two or more
values.
For example,the statement
cout<<setw(5)<<setprecision(2)<<1.2345
<<setw(10)<<setprecision(4)<<sqrt(2)
<<setw(15)<<setiosflags(ios::scientific)
<<sqrt(3)<<endl;

Will print all the three values in one line with the field
size of 5,10,and 15 respectively.
There is a major difference in the way the
manipulators are implemented as compared to the
ios member functions. The ios member function
return the previous format state which can be used
later. In case, we need to save the old format states,
we must use the ios member function rather than
the manipulators.
Example:
cout.precision(2);//previous state
int p=cout.precision(4);//current state;
When these statements are executed, p will
hold the value of 2(previous state) and the new
format state will be 4.We can restore the
previous format state as follows:
cout.precision(p)//p=2
Designing Our Own Manipulators

We can design our own manipulators for certain special

purpose.The general form for creating a manipulator without any
arguments is:

ostream & manipulator(ostream & output)

{
…………
…………(code)
…………
return output
}
Here the manipulator is the name of the manipulator under
creation.
The following function defines a manipulator called
unit that dispalys”inches”:
ostream & unit(ostream &output)
{
output<<”inches”;
return output;
}
The statement
cout<<36<<unit;
will produce the following output
16 inches
We can also create manipulators that could
represent a sequence of operations.
Example:
ostream & show(ostream & output)
{
output.setf(ios::showpoint);
output.setf(ios::showpos);
output<<setw(10);
return output;
}
 Program illustrates the creation and use of
the user-defined manipulators. The program
creates two manipulators called currency and
form which are used in the main program.