Source and Destination of streams, Formatted Input and Output, Buffered Input/Output

<< Dynamic Arrays of Objects, Overloading new and delete Operators

Stream Manipulations, Manipulators, Non Parameterized Manipulators, Formatting Manipulation >>

CS201 Introduction to Programming

Lecture Handout

Introduction to Programming

Lecture No. 35

Reading Material

Deitel & Deitel - C++ How to Program

Chapter. 11

11.1, 11.2, 11.3, 11.3.1, 11.3.2,

11.4, 11.4.1, 11.4.2, 11.4.3, 11.5

Summary

30)

Streams

31)

Source and Destination of streams:

32)

Formatted Input and Output

33)

Recap Streams

34)

Buffered Input/Output

35)

Methods with streams

36)

Examples using streams

Streams

We have been discussing the concept of `Streams' from the very beginning of the course.

In this lecture, various aspects of this concept will be discussed. There are two types of

streams i.e. input streams and output streams. Before going into minute details, we will

see what actually these two types are. You are well aware of the terms `cin' and `cout',

used several times in our previous programs. We have used cout for output and cin for

input. Similarly, the terms of file input and file output are very much known to us. We

leaned how to write in files and how to read from files. These are also streams. Let's have

a look on the things and functions we can do with streams. There are some specific

functions for input and output in C. printf and scanf are normally used in C. In these

functions, we have to tell what type of data we are using and in which variable. Streams

are counterpart of this in C++. The input output system in C++ is streams. As the name

applies, it's a stream of bytes. As told earlier, it may also be termed as a door through

which program can communicate with the outside world. For entering some data, we use

cin stream while the data is read from the keyboard and stored in some variable. To

display data on the screen, we can take help of cout.

Page 446

CS201 Introduction to Programming

For making the things more comprehensive, we will consider the example of a class-

room. Suppose you are sitting in the class and listening to this lecture. All of a sudden,

the students are asked by the instructor to go out of the classroom. How would you do it?

You will get up from the seat and walk through the door. But you can see that all of you

cannot go through the door simultaneously. You would go through the door one by one.

Similarly if you have to come to the classroom, you will enter one by one and sit on the

seats. In a way you are forming a sequence of people in this case. Stream is a sequence of

bytes. It is an ordered sequence. Let's compare it with the door example. The person who

enters first will go out of the door first. The person who enters behind someone will go

out behind that person. Similarly streams are also ordered sequence. The thing that enters

first into the stream will go out first. You should think streams as ordered sequence of

bytes. Byte is a unit of measure. A byte can store one character, so you can think of an

ordered sequence of characters.

As programmers, we communicate with our programs in English through the keyboard.

We may be typing the letters, abc or the numbers, 012 on the keyboard. These all are the

characters. In the programs, we store these characters in variables of different data types.

Sometimes, these may be in some of our objects. On the keyboard, we type the character

`a' that is stored in some variable c in our program. How these two are linked? This link

is formed in cin stream. Consider cin as a pipe or a door. The character `a' is entered

from one side and then a conversion takes place i.e. character is converted into its binary

representation, stored in the character variable named c. So there is an implicit

conversion happening. The same thing happens, if we have an integer i and press the key

1 from the keyboard. The digit 1 travels as a character but inside it is stored as number.

You have to be careful while dealing with this concept. We have talked about the ASCII

characters. On the keyboard, we have alphabets, numbers and symbols. When you press

the number key from the keyboard, it goes at number inside the computer. In general

terms, it is a character. It means that when you enter a key on your keyboard, a character

sequence is generated that later goes into the computer. This character sequence has some

binary representation. It does not mean a sequence of characters, but a code that goes

inside the computer on pressing a key on the keyboard. This code is called as ASCII

code. It is the binary representation of a character. Here both the characters `A' and `B'

have some binary representation. Similarly `0','1','2' have some binary representation. It

does not mean that the character representation of `1' is also `1'. If you are aware of the

ASCII table (you have already written a program to display the ASCII table), it will be

evident that the binary representation of character `1' is some other value. Similarly all

the numbers 1, 2, 3 etc have some ASCII value. So whenever you press any key on the

keyboard, its ASCII code goes inside the computer.

Now when we use cin stream to read some number from the keyboard and store it in the

integer variable, its binary representation is ignored and the value is stored. So cin is

performing this transformation operation. It is taking a character ASCII code and knows

that it is supposed to represent some number. It has the ability to convert it into the

appropriate number before putting it into the integer variable i. What happen if we use cin

to read some value and store it in some integer variable and press some alphabet key

Page 447

CS201 Introduction to Programming

instead of numeric keys. Some error will occur. So in the cin stream, an error can be

detected.

Let's us look at the collection of input and output classes. These are objects having

functions. This collection of classes and their functions are known as input-output

streams in the C++. The most common things that we have been using are cin, used to get

input from the keyboard and cout employed to display something on the screen. So one is

input stream and the other one is output stream. Since we are not going to discuss the

object- oriented programming in this course. We will not discuss the hierarchy through

which these classes are derived. We have some objects for input stream and out put

stream e.g. cin and cout respectively. Being objects, they have member methods that we

can call. They also have the operators like `<<' and `>>', as used in the earlier programs.

These operators `<<', `>>' are heavily overloaded. What does this mean? If we write cin

>> i; here i is an integer. Automatically cin will take a character in ASCII code from the

keyboard, convert it into number and store it into the integer variable. On the other hand,

if we write cin >> c; where c is a character data type. When we press a key from the

keyboard, it will be stored in c as a character. So the stream extractor operator of cin (i.e.

>>, which gets the data from the stream and stores it into the variable) is already

overloaded. It knows how to behave with int, char, float etc data type and what sort of

conversion is required. In case of float number, we have decimal point, cin knows how to

treat it besides converting and storing it into a float variable. Similarly if we use any

character pointer i.e. string, the same >> operator has the capability of reading strings

too. Obviously, one operator can't perform all these functions. It seems that we are using

the same operator. Internally, this operator is overloaded. It is not the same for int, char,

float, string and so on. But due to the operator overloading, its usage is very simple. We

just write cin >> i; it works perfectly.

Source and Destination of streams

As earlier said that streams are sort of door or pipe between two things. What are these

two things? For every stream, there must be some source and some destination. For cin,

the source is normally keyboard and the destination can be an ordinary variable i.e.

native-data type variable. It could be some area of memory or our own data type, i.e.

object for which we have overloaded the operator and so on. So always there is a source

and there is a destination.

cout is output stream. It takes the data from the program and presents it in human

readable form. It also has some source and destination. The source may be some file, or

the region in memory or the processor or a simple variable or our own object of our data

type. The destination is normally screen. The destination can be a file, screen, or printer

etc. You have used file input and file output so you know how it works. When we talk

about area in memory, it may be an array that we read or write. It could also be a

character string which is itself an area in the memory.

"Every stream has an associated source and a destination"

Page 448

CS201 Introduction to Programming

Now we will talk about yet another concept i.e. the state of stream. What does it mean?

We say that cin >> i ; where i is an integer. When we give it the input `a' and press the

key `enter', the stream knows that it is a bad input. So it is capable of signaling and

setting its state specifying that some thing not good has been done. So from a program,

we can always test whether the state of stream is right or not. We should carry out all

kinds of error checking, debugging and error handling while writing programs. We don't

want to manipulate bad data. So checking for this everywhere will be good. For example,

if we write a simple program that takes two integers from key-board, divides one number

by the other and displays the result. Following will be the code segment.

int i, j ;

cin >> i ;

cin >> j ;

cout << i / j ;

Now we have to see what happens if the user gives a value 0 for j. We don't want to

divide it by zero as even the computer does not know how to do it. When we have zero in

j, our program probably will work through an exception or error before coming to a halt.

If we trap this error inside the program, it would be much nicer. We can say if j is not

zero, it will be good to carry out the division. So error checking and handling is always

important. The same thing applies to I/O streams. When we execute input or output

operation, we should check whether the operation has been carried out correctly or not.

To do this, we can check the state of the stream.

Here is a simple example showing the simple use of streams.

/* Avoiding a precedence problem between the stream-insertion operator and the

conditional operator. */

#include<iostream>

int main()

{

int x,y;

cout<< "Enter two integers: ";

cin>>x>>y;

cout<<x << (x ==y ? " is" : " is not") <<" equal to "<< y;

return 0;

}

The output of the program:

Enter two integers: 3 3

3 is equal to 3

Page 449

CS201 Introduction to Programming

Formatted Input and Output

Other things that the streams provide us are a capability of formatted input and output.

We have been using cin and cout very simply without any formatting. As the output of a

program, we do not want that numbers should be printed in a way that makes it difficult

to read and understand. We want to format the output in a way that the numbers are

placed correctly at the correct position on the paper. You might have seen the electricity

bills or telephone bills printed by the computers. First the empty bills are printed in the

printing press containing headings with blank boxes to put in the bill entries. Then the

computer prints the entries in these boxes from the system. These entries (data regarding

the bill) are printed at correct places on the bill. Sometimes, you see that the entries are

properly printed. That is not a computer-fault but only due to poor paper adjustment in

the printer. The printing of these entries is carried out by with the use of formatted output.

The second example is the display of a matrix on the screen. Suppose, we want that the

numbers of a column are displayed up and down in a column. Similarly the second

column should be displayed and so on. At first, we will format these things.

When we do word processing, we type a paragraph. The lines of the paragraph are left

justified but ragged on right hand side. In word processing, we have a choice to justify

the paragraph. By doing this, the left and right margins of the paragraph are put in a

straight line while adjusting the space between the words. Now look what happens if we

want to print a string with cout and want it left or right justified. This is what we call

formatting the output. Similarly, we want to print the value of pi which is stored in a

variable as 3.1415926. But we want that it should be printed as 3.141 that means up to

three

decimal

places.

There should be a method of formatting it. Thus by formatting the output, the presented

representation (which we read as human being) can be different from the internal

representation. So we can do a lot of formatting with these streams.

Besides, there are member functions with the streams. Let's look at the member functions

of cin. The first one is the get function. We can use it by writing:

cin.get();

The notation explains that cin is an object (cin is an object of input stream) and get is a

member function of it. This function reads a character. In this case, it reads a single

character from key board and returns it as cin is calling it. We have two variants of this

get function with cin. One is that cin.get returns a character. W

e can write it as

under:

c = cin.get() ;

The second method is cin.get(character variable) i.e. one character at a time. It works

with characters, not through number or string. It is one character at a time.

Page 450

CS201 Introduction to Programming

The second function of cin is the read function. This function differs from the get

function in the way that it returns a buffer instead of a single character. So we can point

to a buffer and tell the number of characters to be read. We normally provide a delimiter,

a specific character up to which we want to read. Normally we use the new line character

as a delimiter and read a single line at a time.

Thus, we have three ways of obtaining input with cin, which is an object of type input

stream (istream). If we create an object of type istream, it will also get these functions as

it is derived from the same class.

We have seen that there are many methods and operators associated with cin. The same

thing applies to cout. cout is the output stream which usually, presents the data from the

computer in human readable form. The operator associated with cout is the stream

insertion (<<). That means we insert the operator in the stream and the stream displays

the output on the screen. So the operator with cout is << and it displays the value of the

data variable that we provide it after the << sign. Thus to display the value of an integer

variable i, we can write cout << i ; If we want to format the output, it can also be done

here.

The cout has a function write with it. This function can be used if we want to write a

chunk of data from the buffer. Similarly, to output a single character, cout has the

function named put. It can be written as:

cout.put(character variable) ;

Here, it will display the value of the character variable.

Recap streams

Streams are nothing but an ordered sequence of bytes.

They allow data to move from one part of the computer to another which may be the

screen or key board from and to, or from memory or files on disc and so on.

Byte stream is used to connect the source and the destination.

These byte streams are implemented as objects. Being objects, they do have their member

functions and have their member operators. The member operators are heavily

overloaded to allow these streams to handle a variety of data types.

The streams have a state that can be checked by us. We have used eof (end of file) with

the file reading. This is a way to check the state of the stream.

While using I/O streams, we have to include some header files. Whenever we use cin and

cout, the file iostream.h, is included in which all these classes and objects have been

defined. For the formatted input and output, we manipulate the streams. To do stream

manipulations, we have to include a header file having the name iomanip.h. We can

understand that iomanip is a short hand for input output manipulation.

Page 451

CS201 Introduction to Programming

Now let's take a look at the standard streams which are provided to our programs.

Whenever we write a C++ program and include iostream.h in it, we get a stream for input

(reading) that is cin. This is a built in thing. We can use this object. Similarly, for output

(writing), we get cout. Other than these, we get some other streams by default. These

include cerr (read as c error) and clog. To understand these streams, we have to talk

about buffered input and output.

Buffered Input/Output

In computers, most of the components relate to electronics like chips, memory, micro

processor etc. There are also electro-mechanical things like disc. The key board itself is

an electro mechanical accessory. The electro mechanical parts of the computer are

normally very slow as compared to the electronic components. So there is a difference

between the two in terms of speed. Secondly, every input/output operation costs

computer time. Input/output costs and the I/O devices (keyboard, monitor and disc etc)

are slower as compared to the speed of the microprocessor and the memory being used.

To overcome this speed difference, we use the mechanism, called buffered input/output.

Suppose, we have a program which executes a loop. That loop outputs a number in each

of iteration to store in a file on the disc. If we write the output number to the disc in each

iteration, it will be the horrendously wastage of computer time. It means that the disc is

electro mechanical device. Similarly in each iteration, the mechanical movement takes

time. But if we gather the data and write it to the disc, there will be one mechanical

movement. The heads of the disc will move mechanically once to a point and the whole

chunk of data will be written on the disc. This is the more efficient way of using the disc.

So whenever we have a program that writes the output data to the disc, it will be nice to

collect the output data (numbers) and write it on the disc in one write operation instead of

writing the numbers one by one. The area where we gather the numbers is known as

buffer. The example stated in this case is the buffered output. In this case, the output does

not go directly to the disc. We first gather the data in a buffer and then write it on the

disc.

Now think about another situation. Suppose we have a program that performs very

complex calculations. It means that there is a while loop that performs so heavy

calculations that each of the iteration takes, say one minute and then provides the result.

Now we want to write that output to a file on the disc and see the iteration number of the

loop on the screen. We do not want to write the output to the disc after each iteration. We

gather the data in a buffer. In the meantime, we want to see the loop counter on the

screen. If we gather this output of counter number in a buffer, it may happen that the

buffer gathers the iteration numbers for 250 iterations before displaying it on the screen.

Thus, we see on the screen the numbers 1, 2, 3 .....250, when 250 iterations have been

performed. There are again 250 numbers gathered at one time. We see numbers 251, 252

......500, when 500 iterations have been performed. When we start the program, there

will be two buffers gathering data. One buffer gathers the data to write to the disc and the

other gets the data of iteration numbers to display on the screen. As we said that each

iteration takes one minute, meaning that the iteration numbers will not be seen for a long

time. Rather, these will be shown after 250 iterations (i.e. 250 minutes). During this

Page 452

CS201 Introduction to Programming

period, we do not show any thing on the screen. Here, we are not sure whether the

program is executing properly as we do not see any iteration number on the screen. We

want to know after every minute that loop has executed once. So after every minute, the

loop counter should be displayed on the screen, so that at any time we could see how

many iterations have been performed. For this, we need unbufffered output on the screen.

Thus, in the same program we require buffered and unbuffered output.

Now these requirements are contradictory with different issues. These are met in our

system with the cerr object. cout is a buffered output. We cannot see it as nowadays

compilers are very intelligent. If you know UNIX, or command prompt and input output

redirection, we can actually see this in operation. Perhaps, you can create an example to

understand this. For the moment just try to understand that cout is buffered output. It

gathers data and sends it to the screen. On the other hand, cerr is unbuffered output. It

will show the data on the screen at the same time when it gets it. So cerr is an output

stream, an ostream object but unbuffered. It shows data immediately. So we can use

something like the cerr object that will show how many loops have been executed. It will

use something like cout to write on the disk to buffer the output. In this case, we are

getting efficiency in addition to information. Normally we use cerr object in C++ for this

purpose. Besides, we also have clog. It is also known as standard log having detailed

information of the log. To collect information of the program, we write it with clog.

Normally when we execute our programs- cout, cerr and clog, all are connected to

screen. We have ways to direct them at different destinations. That depends on the

operating system. Suppose, we specify the buffer size, normally the operating system or

compiler does this for us. A typical size of buffer is 512 bytes. When the information is

of 512 byte size, output will take place. But in the program, we may want at some point

that whatever is in the buffer, show them. Is there a way of doing that? The normal

mechanism is flush. Flush the stream. The flush command forces the data from the buffer

to go to its destination which is normally a screen or file and make the buffer empty.

Uptil now, we have been using two things to end the line. One is new line character i.e.

"\n". When we are displaying something on the screen, it makes the next output to start

from the next line. The cursor moves to the left margin of the next line on the screen.

New line is just a character. The other one was endl. If we write cout << endl; It seems

that the same thing happens i.e. the cursor moves to the left margin of the new line. But

endl actually does something else. It flushes the output too. As a result, it seems that cout

is unbuffered i.e. its output is immediately available on the screen. Depending on the

compiler and operating system, you may or may not see the buffered effect. But one thing

is clear that while reading the source code, you will know where cout is used and where

cerr. Typically, that is also the programming style where the output of cerr is informative

and small. It shows that where is the control in the program. The output of cout is more

detailed and the actual output of the program. There are benefits of these things in the

code. In case of cin, it is alone. For output, we have cout, cerr and clog. In DOS, we have

two more output streams i.e. caux (auxiliary input output stream) and cprn (printer

output). These are no more relevant now.

Predefined Stream Objects:

Page 453

CS201 Introduction to Programming

Object

Meaning

cin

Standard input

cout

Standard output

cerr

Standard error with unbuffered output.

clog

Standard error with buffered output

caux

Auxiliary (DOS only)

cprn

Printer(DOS only)

Now let's take a look at the operators associated with these streams. We have been using

the stream insertion operators `<<' with cout. We need to understand that how these

operators are implemented. Using cout, we can chained the output. It means that we can

write as cout << "The value of the first integer is " << i; This is the single cout

statement. How does that work? What happens is the first part goes to cout. In this case, it

is the string "The value of the first integer is". The data travels in the direction of the

arrows. This string is inserted in the stream and displayed on the screen. What about the

rest of the statement i.e. << i; this again needs cout on the left side to be executed. It

should look like as cout << i; Once, we have defined that this is the behavior expected

by us. Then, we understand that this is exactly the way it has been programmed. The

stream insertion operator `<<' is overloaded for the output stream and it returns the

reference of the output stream. The syntax of stream insertion operator is:

ostream& ostream::operator << (char *text);

The important thing to note is that this operator returns the reference to the ostream

object itself. Whenever we write a chained output statement, it is executed from left to

right. So cout << " The value of the first integer is" is processed first from left to right.

The process is that this character string is displayed on the screen. As per the prototype

and definition, it returns the reference to the ostream object. In this case, the object was

cout, so a reference to the cout object is returned. Now the rest of the statement becomes

as cout << i; It is processed quite nicely. This allows the stream insertions to be chained.

It is also applicable to the input. So if we say something like cin >> i >> j; both i and j

are integers. Now again, it is processed from left to right. This is the istream and the

extraction operator will return the reference to the istream object i.e. cin. So at first, the

cin >> i is processed which will return the reference to the cin object. The rest of the

statement seems as cin << j; It is important to understand how these operators work. You

can see their prototypes that they return iostream objects themselves. That is the why, we

can chain them. Now let's see what are the other various methods associated with these

input output streams.

Methods of streams

There are some other functions associated with cin stream. We have used some of them.

We have used get() and read() methods with input stream. Another member function of

cin is getline(). It reads a complete buffer i.e. the number of character specified up to a

delimiter we specify. We can write something like:

cin.getline(char *buffer, int buff_size, char delimiter = `\n')

Page 454

CS201 Introduction to Programming

The character data is stored in *buffer. buff_size represents the number of characters to be

read. If we specify its value 100, then getline will read 99 characters from the keyboard

and insert a null character in the end. As you know, in C++ every character string ends

with a null character. We can also give it a delimiter. Sometimes, we may want to read

less character. Normally, the delimiter is the new line character. So while typing on the

keyboard, if we press the enter key then it should stop reading further and put the data

into the variable buffer. So there is a getline fiunction.

There are some other interesting functions also. When we use cin.get(), a character is

read. We can throw back the character gotten by this get function by using the unget()

function. So we can use cin.unget() that will return the most recently (last) gotten single

character.

We have a function peek(), also written as cin.peek(); The purpose of this function is that

we can see the next character that we are going to get. This function returns the next

character that would be read if we issue cin.get().

All these functions (getline, get, read, unget and peek) are implemented as member

functions of the input class.

Similarly, there are functions associated with cout. We have cout.putline(); which outputs

a buffer. Actually we have no need of this function because cout, itself, knows how to

handle character strings. Then we have cout.write(); which can perform a raw,

unformatted output. The function cout.put(); is like a formatted output. It performs

character by character output. We can do many formatting conversions by using the

stream insertion operator (i.e. <<) with cout. We can write an overloaded function of

stream insertion (<<) to input or output a complex number. We know that a complex

number has two parts i.e. real and imaginary. We can write the overloaded function such

that if we give two numbers with space between them it could read it. We can also write

it as that it could read two numbers (that are real and imaginary parts of a complex

number) separated by comma. Thus there may be different ways to write the overloaded

operator.

The white space character is very significant. We can show it by a simple example.

Suppose we have an array name of 60 characters. We get a name from the user in this

array by using cin and then display this string by cout. The code segment for this purpose

can be written as:

char name [60] ;

cin >> name ;

cout << name ;

Now when the user enters the name, suppose it enters `naveed malik' that is a name

containing two words with a space between them. When we display this name by using

cout, only `naveed' is displayed on the screen. It means that only one word `naveed' was

Page 455

CS201 Introduction to Programming

stored in the array. The reason for it that the streams (cin, cout) are sensitive to white

space character that is treated as a delimiter. Now where is the second word `malik'. It

has not got deleted yet. It is in the buffer of the stream. This example will read like the

following:

char nam1 [30], name2 [30] ;

cin >> name1 >> name2 ;

Thus, we have two character arrays now. We can write `naveed malik' and press enter.

The first part before space (naveed) will go to the first array name1 when that array is

used with cin. We will write another cin with name2 and the second part (malik) will go

to the second array name2. So things don't disappear. They stay in the buffer till you

actually expect them. We have to be careful about that.

Examples using streams

A simple example showing the use of getline function.

// A simple example showing the use of getline function.

#include <iostream.h>

int main()

{

const int SIZE = 80;

char buffer[SIZE];

cout << " \n Enter a sentence: \n" ;

cin.getline(buffer, SIZE);

cout << " The sentence entered is: \n" << buffer << endl;

return 0;

}

Output of the program.

Enter a sentence:

this is a test

The sentence entered is:

this is a test

A simple example showing the use of read and write functions.

// A simple example showing the use of read and write functions.

#include <iostream.h>

int main()

{

const int SIZE = 80;

Page 456

CS201 Introduction to Programming

char buffer[SIZE];

cout << " \n Enter a sentence: \n" ;

cin.read(buffer, 20);

cout << " The sentence entered was: \n";

cout.write(buffer, cin.gcount());

cout << endl;

return 0;

}

Output of the program.

Enter a sentence:

This is a sample program using read and write functions

The sentence entered was:

This is a sample pro

Page 457

Table of Contents: