Transcript STREAM HANDLING - CodeDuniya.com

STREAM HANDLING
• The I/O system in C++ is designed to work with a
variety of including terminals, disks and tape drives.
Although each device is different, the I/O system
supplies an interface to the programmer the actual
device being accessed. This interface is ‘stream’.
• Stream is a sequence of bytes. It acts either as a
source from which the input data can be obtained
or as a destination to which the output data can be
sent. Source stream is input stream and destination
stream that receives output is the output stream.
• C++ provides with a library of classes that have the
functionality to implement various aspects of
stream handling. Hierarchy is shown below:
ios
istream
ifstream
Istream_withassign
ostream
iostream
fstream
ofstream
Ostream_withassign
• Class ‘ios’ is the base class.
• ‘ostream’ is derived from ‘ios’ and handles the
general output stream. The insertion operator is
defined and overloaded in this class to handle
output streams from program variables to output
files. ‘ostream_withassign’is derived from ‘ostream’.
cout is an object of the class ‘ostream_withassign’
and stands for console output. C++ treats
(peripherals) monitor as file and ‘cout’ represents
the monitor.
• cout<< x ; is translated as – ‘insert the stream ‘x’
from program variable in to the file called ‘cout’ ’.
• ‘istream’ is derived from ‘ios’ and handles the
general input streams. Extraction operator is
defined and overloaded in the class ‘istream’ to
handle input streams from input files to program
variables. ‘istream_withassign’ is derived from the
‘istream’. ‘cin’ is the object of that class and stands
for console input. ‘cin’ represents the keyboard.
• cin >> x; is translated as - extract the stream from
the file and place it in the program variable ‘x’.
• The class ‘iostream’ is derived from multiple
inheritance fro ‘istream’ and ‘ostream’. It has the
functionality to handle both input & output streams
• Class ‘ofstream’ is derived from ‘ostream’, having
the functionality to handle output streams to disk
files. Objects of ‘ofstream’ represent output files on
the disk. ofstream ofile (“first.dat”); this code
opens a file for output (argument is passed as a
string to the constructor of the class ).
• Since the insertion operator is defined in the base
class of ‘ofstream’ the object ‘ofile’ can be passed
as the LHS operand instead of ‘cout’ ofile<<x;
this is translated as “insert the stream from the
program variable ‘x’ in to the file ‘first.dat’ ” .
• Class ‘ifstream’ is derived from ‘istream’ to handle
input streams from disk files. Objects of ‘ifstream’
represent input files on the disk.
ifstream iflie(“first.dat”); opens a disk file for input.
• Since >>is defined in base class ‘ifstream’ the object
‘ifile’ can be passed as lhs operand. ifile >> x ;
translated as – “ extract stream from file and place
it in the program variable ‘x’. ‘fstream’ is derived
from class ‘iostream’ and can handle both input and
output streams from and to disk files.
• The classes for handling streams to and from disk
files are defined in the header file ‘fstream.h’.
For handling general streams in ‘iostream.h’.
Header file ‘iostream.h’ is included in ‘fstream.h’
Text and binary input/output
• How data is stored in memory?
• During runtime, the value of char variable is stored
in memory as the binary equivalent of it ASCII
equivalent. But value of int, float or double type is
simply stored in its binary equivalent.
• Value of char ‘A’ is stored in one byte (number 65,
ASCII equivalent of ‘A’, in base 2). If it is integer, then
it is stored in four bytes, bits representing 65,base 2
• There is no difference between text mode I/O and
binary mode I/O with respect to character type
variables. In both modes value is copied to/from
memory /output or input file as it is.
• Numeric data needs to be output in base 10(text)
format which is in base 2 format in memory –
requires transformation in representation of data.
Standard library functions will handle this.
• Suppose an integer value ‘65’ is stored in memory
occupying four bytes. It will occupy the same bit
setting in the output disk file, if it is copied by an
output function that outputs in binary mode.
• If the same function outputs to monitor, instead of
disk file, the value ‘A’ followed by three blank
spaces will be displayed. But we would like to see
‘65’ and not ‘A’.
• If the same value is copied by an output function
that outputs in text mode, it will occupy two bytes
with different bit settings, in the output file. First
byte will represent ‘6’ and the second ‘5’.
• In case of input, if the input value is in text mode it
should be copied to memory after transforming to
binary mode. If in binary mode then simply copy.
• Text mode is suitable for console I/O because they
are in base 10 format with which we are
accustomed.
• Text and binary files
• In text files, binary data (numeric data that is stored
in base 2 format in memory) is stored in base 10
format. In binary files the same binary data is stored
in base 2 format. Binary/text is the mode in which
the data is written into the files defines the nature.
• The size of output file containing integer values is
always multiple of four.
• The c++ standard library provides functions that
input in binary mode. These function require the
address of the variable whose data needs to be
input along with its size. The size of the block of
bytes this code reads is equal to the supplied size
• The binary functions that write data into disk files
need not insert an artificial delimiter while the data
is output. (treat the size as the delimiter)
• In text mode, the records stored in the output file
are of variable lengths. ‘1’ occupies one byte, ‘11’
two bytes and so on in disk file, although each
occupies four bytes in memory.
• In case values are output in text mode, size of the
output value is not fixed. Hence size can not be
used as the delimiter. To ensure the correct
interpretation of the value, the code calls a text
mode function for output should also insert a
delimiter of choice in the output file after every call
• There should be no chance of delimiting character
itself becoming a part of the output value any time
in future. The size of file does not indicate the
number of records stored in it.(record size not fixed)
Text input / output
• The insertion operator : - is defined and overloaded
in the class ‘ostream’. It takes an object of class
‘ostream’ or an object of a derived class from that,
as LHS operand. RHS operand is one of the values of
built in types.
• Inserting characters into output streams using the
insertion operator:- character value occupies 1 byte
in memory and same in output file in text mode
#include<fstream.h>
void main()
{ char cVar;
ofstream ofile (“first.dat”);
cVar = ‘A’ ; ofile << cVar;
}
• Last statement copies the values of cVar from
memory to the disk file without transforming.
• Inserting integers into output streams using the
insertion operator:
#include<fstream.h>
void main()
{ int iVar;
ofstream ofile (“first.dat”);
iVar = 111 ; ofile << iVar;
}
• Integer occupies 4 bytes in memory. In text mode it
depends upon its value. ‘111’ will occupy 3 bytes.
• Inserting float and double into output streams using
the insertion operator:- It is same as inserting
integers into output streams using the insertion
operator. ‘1.111’ occupy 5 bytes.
#include<fstream.h>
void main()
{ int fVar;
ofstream ofile (“first.dat”);
fVar = 1.111 ; ofile << fVar;
}
• Inserting strings into output streams using the
insertion operator:- A character array is allocated
a fixed number of bytes in the memory during run
time. However the actual string contained in it
usually occupies only part of that memory. For
example
char cArr[20]=“abcd”; When this is
output by ‘<<‘ it will occupy only 4 bytes in file.
void main()
{ char cArr[20]=“abcd”;
ofstream ofile (“first.dat”);
ofile << cArrVar;
}
• Inserting objects into output streams using the
insertion operator : we have to overload the
operator for that class.
• The put() function : is a member of ‘ostream’ class.
Its prototype is – ostream & ostream:: put(char c)
The function can be called with respect to an
object of the class ‘ostream’ or its derived classes.
One such object is ‘cout’.
The function copies the character that is passed as a
parameter to it in to the output file associated with
the object with respect to which the function is
called.
void main()
{ ofstream ofile (“first.dat”);
ofile.put(‘a’);
}
• Character ‘a’ is written in to the file
void main()
{ cout.put(‘a’); } //display ‘a’ on the monitor
The difference between the insertion operator and
put() function is that while the former modifies the
format of the output with respect to the
manipulators set earlier, the latter simply ignores
format manipulator settings.
Text input:
• It is achieved by (i) extraction operator (ii) get()
function
(iii) getline() function
• Extraction operator can be used to input values
from disk files and inputs in text mode
• It has been defined and overloaded in the class
‘istream’. It takes an object of the class ‘istream’ /its
derived classes as its LHS operand. It takes a
variable of one of the fundamental data types as its
RHS operand. It copies the value found at the
current location in the file that is associated with
the object on its left in to the variable on its right.
• Extracting characters from input streams using the
extraction operator: if the RHS operand is a char
type variable, it reads one byte from the input file
#include<fstream.h>
void main()
{ ifstream ifile (“first.dat”);
char cVar;
ifile >> cVar; cout<<cVar;
}
that is attached with the object on its left and
writes it into the variable.
• Extracting integers from input streams using the
extraction operator: if the RHS operand is an integer
type variable, it reads one byte from the input file
that is attached with the object on its left until it
finds a white space. The extraction operator
converts the read value(in base 10 format) into
base 2 format and writes into the variable.
#include<fstream.h>
//input : 11 22 33
void main()
{ ifstream ifile (“first.dat”); int iVar;
ifile >> iVar;
cout<<iVar; }
//output: 11
• Extracting floats and doubles from input streams
using the extraction operator: in the same way as
they are for integer type variables.
• Extracting strings from input streams using the
extraction operator: As in the case of integers, it
reads from the file until it finds a white space while
reading value for a character array.
#include<fstream.h>
//input : abc def ghi
void main()
{ ifstream ifile (“first.dat”); char cArr[20];
ifile >> cArr;
cout<<cArr; }
//output: abc
• Extracting objects from input streams using the
extraction operator:have to overload it for that class
The get() function
• It has been defined in the class ‘istream’. It reads
one byte from the input file and stores it in the
character variable that is passed as a parameter to
it. Prototype is : istream & istream::get(char&);
#include<fstream.h> //contents of file : abcd
void main()
{ ifstream ifile (“first.dat”); char cVar;
ifile.get(cVar);
cout<<cVar; } //output: a
The getline() function
• It reads one line from the input file. Defined in class
‘istream’. It takes three parameters. The prototype –
istream & istream :: getline (char * , int, char=‘\n’)
• The first parameter is the name of the array in
which the read line will be stored. Second is an
integer, signifies the number of bytes that will be
read from the input file. Third one is the delimiting
character, prevents from reading further.
#include<iostream.h> //read from key board
void main()
{ char cArr[20]; cout<<“Enter a string:”;
cin.getline(cArr,6,#);
cout<<“you entered :” <<cArr <<endl; }
output: Enter a string :abcdefgh /abc#de/aa bb cc
you entrred : abcde /abc/aa bb
• It reads bytes one less than the second parameter
or till it encounters the delimiting character
whichever occurs earlier. It reads white space also.
It reads from the keyboard buffer and leaves behind
the unread bytes in the buffer itself.
#include<iostream.h>
void main()
{ char cArr[20]; ifstream ifile(“first.dat”);
ifile.getline(cArr,6,#);
cout<<“you read from file :” <<cArr <<endl; }
output: you read from file :abcde /abc / aa bb
• It works in a similer fashion when it reads from disk
files. If the contents of file : abcdefgh / abc#def or
aa bb cc then the output would be as above
Binary Input/ output
• The write() function : - It copies the values of
variables from the memory to the specified output
file. It works in binary mode.
• Binary mode functions are not concerned about the
data types of the variables that is output. They are
only interested in the address of the variable and
the size of the variable. Prototype of write() is:–
ostream & ostream :: write (const char * , int )
• It has been declared in the ‘ostream’ class and takes
two parameters. First one is the address of the
variable and the second one is the size. It writes the
value of variable to the file, associated with object.
• Inserting characters into output streams using the
write() function:- following functions illustrate how
the write() can be used to output the value to a disk
file and monitor. There is no difference between
outputting a char type value in text & binary mode.
#include<fstream.h> //to disk file
void main()
{ ofstream ofile (“first.dat”); char cVar;
cVar=‘a’;
ofile.write(&cVar,sizeof(char)); }
#include<iostream.h> //to monitor
void main()
{ char cVar;
cVar=‘a’;
cout.write (&cVar, sizeof (char) ) ; } //output: a
• Inserting integers into output streams using the
write() function: the value contained in four bytes
that are occupied by ‘iVar’ will copied to the
designated output file without any transformation
#include<fstream.h> //to disk file
void main()
{ ofstream ofile (“first.dat”); int iVar;
iVar=65; ofile.write((char*)&iVar, sizeof(int)); }
#include<iostream.h> //to monitor
void main()
{ int iVar;
iVar=65;
cout.write((char*)&iVar, sizeof(int)); }
output : A
• The monitor shows the ASCII equivalent of each of
the bytes passed to it.
• The difference between outputting an integer type
value in text mode(put()) and binary mode (write())
is – in the former, the read value is transformed to
base 10 format and then copied to output file.
There is no such conversion in the latter case.
• Inserting floats and doubles into output streams
using the write() function: same as integer type.
• Inserting strings into output streams using the
write() function:- the name of the array is the
starting address and the second parameter is the
size of memory block whose value is to be written
into the output file. Since 10 is the size it copies one
byte at the end with junk value.
#include<fstream.h> //to disk file
void main()
{ ostream ofile (“first.dat”);
char cArr[10]=“abcdefgh”;
ofile.write(cArr, sizeof(cArr)); }
#include<fstream.h>
//to monitor
void main()
{ char cArr[10]=“abcdefgh”;
cout.write(cArr, strlen(cArr)); } output:abcdefgh
• Inserting objects in binary mode:- value of the
object in memory block is copied to file
#include<fstream.h>
//to disk file
class A { //dfefinition of class A }
void main()
{ A A1 ;
ostream ofile (“first.dat”);
ofile.write((char*) &A1, sizeof(A));
}
• The value of the object is directly accessed by a
non- member function and c++ does not prevent
explicit typecasting of an object’s address. This is
allowed – char* cptr = (char * )&A1;
• ofile.write((char*) &S1, sizeof(String)); when this
code is executed for string object, instead of string,
the pointer cStr is copied to the file. When this
value is later read through another program,
it would end up with a location where the string no
longer exists! Hence client programs are not
supposed to know how the actual data is managed.
• Objects should be responsible for outputting their
own data (linked lists, vectors, trees etc. )
Binary input : read()
• It copies the values from the specified input file to
the memory block occupied by the target variable.
It works in binary mode. It accepts the address of
the variable and the size of the variable . Prototype
is – istream & istream :: read (char*, int) ;
it is from class ‘istream’. First parameter is the
address of the variable into which the read value
needs to be input. Second parameter is the size of
the variable.
• Extracting characters from input streams using the
read() function:- if contents of file are : xyz
#include<fstream.h> //read from disk file
void main()
{ ifstream ifile (“first.dat”); char cVar;
ifile.read(&cVar,sizeof(char));
cout<<cVar; }
//output: x
#include<fstream.h> // read from console
void main()
{ char cVar; cout<<“Enter a character:”;
cin.read(&cVar, sizeof (char) ) ; cout<<cVar; }
• There is no difference between inputting a
character type value in text mode (extraction
operator, get() ) and in binary mode( read() ). There
is no conversion in either case.
• Extracting integers from input streams using the
read() function:- if first four bytes contain 64
#include<fstream.h> //read from disk file
void main()
{ ifstream ifile (“first.dat”);
int iVar;
ifile.read ( (char *)&iVar, sizeof(int) );
cout<<iVar; }
//output: 64
It copies the read value into the memory block the
address of whose first byte is that of first parameter
• To read the value of an integer from the keyboard,
reads four bytes from the keyboard, not converts in
any way and copy them into the four bytes that are
occupied by the target integer type variable.
#include<fstream.h> //read from disk file
void main()
{ int iVar; cout<<“Enter a value in base2 format:”;
cin.read ( (char *)&iVar, sizeof(int));
iVar=iVar&0x000000ff; //to input zeros in the upper
cout<<iVar; }
//three bytes of 4 bytes of iVar
output: Enter a number in base2 format: ABCD
65
• Extracting floats is same as integers
• Extracting strings from input streams using the
read() function:- contents of ‘first.dat’- abcdef
#include<fstream.h> //read from disk file
void main()
{ ifstream ifile (“first.dat”);
char cArr[20]=“123456”;
ifile.read(cArr,3);
cout<<cArr<<endl; } //output: abc456
• ‘3’ has been passed as the second parameter.
Hence it reads only 3 characters. First parameter is
the name of the array and the 3 characters read
from the beginning of the file are copied to array.
• Extracting objects from input streams using the
read() function:- The following statement reads
file.read ((char*) &A1,sizeof(A));
the data from file and loads back to an object.
• In case of complex objects, we need to have the
function that reads the entire data from disk files.
Opening and closing files:
• The open() function: - This function is provided in
both ‘istream’ and ‘ostream’ classes. Syntax is
ofile.open(“first.dat”); ifile.open(“first.dat”);
• A second parameter (known as ‘open mode’) an
integer value can also be passed to this function.
ios:app - for appending to end of file
ios:ate – for going to end of file on opening
ios:binary – for opening a binary file
ios:in – for opening a file for reading only
ios:nocreate – for causing open to fail if the file
does not exist
ios:noreplace – for causing open to fail if the file
does already exists
ios:out – for opening a file for writing only
ios:trunc – for deleting contents of the file if it exists
• The constructor of ‘ostream’ takes ‘ios:out’ as the
default value for second parameter. Also ‘istream’
takes ‘ios:in’ default. The above constants can be
meaningfully combined using bitwise OR (|)
ofile . open (“first.dat” , ios:app | ios:nocreate ) ;
• The close() function : - closing the file with in a
program may be needed when we want to write in
to a file that we have opened for reading and vice
versa. It is defined in both ‘istream’ and ‘ostream’.
Syntax is - ofile.close();
• The overloaded version of open() for the ‘fstream’
class does not take a default value for the second
parameter. We have to specify explicitly whether we
want to open the file for reading or writing or both.
Iofile.open(“first.dat” , ios:in| ios: out ) ;//for both
• File pointers : - are created and maintained for
open files during runtime. There are two file
pointers – the ‘put’ pointer and the ‘get’ pointer.
• These can be explicitly manipulated by the use of
some functions that are the members of stream
handling classes.
• The seekp() function:- is used to make the put
pointer point at a desired position in the open file.
By default it points at the beginning if it is newly
opened for writing. In case of existing file opened
for appending, it points at the end. Every write
operation pushes forward the put pointer by the
number of bytes written.
It is defined in ‘ostream’ and has two versions.
ostream& ostream :: seekp( streampos pos) ; and
::seekp(streamoff off, ios:seek_dir dir) ;
• In the first version, it takes only one parameter, the
absolute position with respect to the beginning of
the file. Type ‘streampos’ is type defined with ‘long’.
Numbering of the position starts from zero.
ofile.seekp(1); put pointer points at second byte.
• The second version takes two parameters – first one
is the offset and the second one is the position in
the open file with respect to which the offset is
being specified. Type ‘ios:seek_dir’ is an
enumerated type with values ios:beg, cur and end .
ofile.seekp(-1, ios:end); - points at the last byte
ofile.seekp(0, ios:beg); - points at the beginning
ofile.seekp(2, ios:beg); - points at the third byte
ofile.seekp(-2, ios:cur); - points at two bytes to the
left from its current position.
ofile.seekp(0, ios:end); - points at past the last byte
Difference between ‘app’ and ‘ate’ flags : - neither
of the two overwrites an existing file. ‘ate’ allows
you to rewind the put pointer and modify the
existing contents of the file, where as ‘app’ does not
allow this. It points at the end of the file, as you
append it moves forward. It can not be rewound.
• The tellp() function :- it returns the current position
of the put pointer. Defined in class ‘ostream’ with
syntax – streampos ostream :: tellp() ;
To determine the current position of the put pointer
• The seekg() function:- used to explicitely make the
get pointer at a desired position in the open file. By
default the get pointer points at the beginning of
the file that is opened for reading. Every read
operation pushes forward the get pointer by the
number of byte reads. Defined in class ‘istream’
istream & istream :: seekg(streampos pos);
istream & istream :: seekg(streamoff off,
ios::seek_dir dir ); //explanation similar to seekp()
• The tellg() function:- like tellp() it returns the
current position of get pointer. Defined in ’istream’.
Streampos istream :: tellg() ; //syntax
long pos = ifile.tellg();
// to store position in a
Random access to files
• Seekp() and seekg() functions are used for random
access. iofile is an object of class ‘fstream’
iofile.seekp( (n-1)* sizeof(int), ios::beg );
• This statement causes the file pointer to point at
the nth record. This works if the size of all records in
the file is equal. Possible only if binary data is stored
in binary mode.
• To find the number of records iofile.seekp(0,ios::end) ;
long lsize= iofile.tellp();
int iNoOfRec = lSize / sizeof(int);
Object input/output through member functions
• Classes that have pointers that point at externally
held data should also have the necessary
functionality to output and input their data .
class String
//#include<fstream.h>
{…
public: …
void diskOut (ostream & fout)
{ fout.write(( char *) & len, sizeof(int);
for(int i=0; i<len; i++) { fout.put(cStr[i]); } }
void diskIn (istream & fin)
{ String temp; // input the string’s length
fin.read( (char *)& temp.len, sizeof(int) );
temp.cStr = new char(temp.len+1);
for ( int i=0; i<temp.len+1; i++ )
fin.get( temp.cStr[i] ) ;
temp.cStr[i] = ‘\0’ ;
*this = temp ;
};
void main()
String s1 ;
s1.setcStr(“abcd”) ;
ofstream ofile (“c:\\string.dat”) ;
s1.diskOut(ofile) ;
ofile.close() ;
String s2;
ifstream ifile (“c:\\string.dat”) ;
s2.diskIn (ifile) ; cout<<s2.getcStr()<<endl ;
ifile.close() ;
}
output: abcd
Error handling
• Error object of class ‘istream’, ‘ostream’ – contains
three flags that indicate the state of next byte in the
associated file.
(i) eofbit – becomes true if the eof is encountered
(ii) failbit–becomes true if read/write operation fails
(iii) badbit- becomes true if the file being read is
corrupt beyond recovery
• The eof() function :- whenever the file pointer
encounters the end of file mark while reading the
file, it sets the value of ‘eofbit’ to true. It returns the
result of past read. It does not looks ahead before
returning the result. Hence the test is given at the
•
•
•
•
beginning of the loop.
The fail() function :- it returns true if the file could
not be opened for any reason. Whenever the
open() fails to open a file, it sets the ‘failbit’ to true.
Another reason is – the non-existence of the file
that is being opened for reading or writing by using
the ‘ios::nocreate’ flag. Also for the file being
opened for writing by using ‘ios::noreplace’ flag but
it already exists. Some other reasons are:
The file being opened for writing is readonly.
There is no space on the disk.
The file being opened for writing is in a disk that is
write-protected.
• The bad() function:- it returns true whenever a
function that is reading from a file encounters a
serious I/O error. Under such circumstances, the
value of the ‘badbit’ flag gets set to true. It is best
to abort I/O operations on the stream in this
situation.
• The clear() function:- it is used to clear the bits
returned by the ‘bad()’ function. This is necessary
under a number of circumstances. For example,
when we use ‘iofile.eof()’ and the ‘eofbit’ sets to
true, then we can not further continue the write
operation unless we use the clear() function.
• Manipulators :- are used to format the output. Predefined manipulators are available and the
programmer can create his own.
• Manipulators can be inserted in an output stream
just like values are inserted for output.
out<<manip1<<manip2<<value1<<manip3<<value2;
out is the object of the class ‘ostream’. ‘cout’ can
also be used to format the output to the monitor.
• Predefined manipulators:
• The setw() manipulator: - takes an integer type
variable as its only parameter. This specifies the
width of column within which the next output will
be output. If the value that is output after this
manipulator is passed in the ‘insertion’ stream
occupies less number of bytes than the specified
parameter, then extra space will be created in the
column that will contain the output value. The extra
space will be padded by blanks or by the character
that is passed as a parameter to the ‘setfill()’ func.
cout<<123<<enbdl; cout<<setw(3)<<10;
output will be : 123
10 the setw() manipulator has
to be used separately for each item to be displayed.
cout<<setw(5)<<10<<setw(5)<<234<<endl;
no truncation of data occurs if the parameter that is
passed to the setw() function is not sufficient to
the padding requirement implied by the setw()
function is ignored.
• The setprecision() manipulator: - by default, c++
displays the values of float and double type with
six digits after the decimal point. However we can
pass the number of digits we want after the
decimal point as a parameter to the manipulator.
cout<<setprecision(3)<<sqrt(3)<<endl<<1.14159;
output : 1.732
1.142 unlike the setw(), setprecision()
retains its effect even after outputting the value.
• Setfill() manipulator:- we can specify the padding
caharacter by passing it as a parameter
cout<<setfill(‘*’)<<setw(5)<<10<<setw(5)234<<endl;
output : ***10**234
• The setiosflags() manipulator:- it is also used to
format the manner in which the output data is
displayed. The two parameters it takes are
‘ios::showpos’ and ‘ios::showpoint’ . ‘ios::showpos’
ensures that the positive sign is prefixed to numeric
data when they are displayed.
cout<<setiosflags(ios:: showpos)<<10;
output: +10
the ‘ios::showpoint’ ensures that the number of
significant digits in the value being output is less
than that specified by the ‘setprecision()’
there by are filled with zeros.
cout<<setprecision(3)<<2.5<<endl
<<setiosflags(ios::showpoint)<<2.5<<endl;
output: 2.5
2.500
• The resetiosflags() manipulator:- this cancels the
effect of the parameter that was passed to an
earlier call to the setiosflags() manipulator.
Cout<<setprecision(3) <<2.5<<endl
<<setiosflags(ios::showpoint)<<2.5<<endl
<<resetiosflags(ios::showpoint)<<2.5<<endl;
output: 2.5
2.500
2.5
• User-defined manipulators :- can be done by
defining a function as follows:
ostream & <manipulator> (ostream & out )
{ /*statementsa*/ return out; } an example ostream & currency ( ostream & out)
{ out<<“$. ”; return out; } now if we write
cout << currency << 20 ; output : $ 20
these enable modularity. It can be used throughout
an application to format the output in a uniform
manner. If change is required, it needs to be carried
out at only one place- the definition of the
manipulator and again the change occurs uniformly
through out the application.