CS 225 Notes 8
-
iostream classes
Added to allow extensibility to I/O functions and efficiency. Only
the parts you use are loaded. Only printing strings? The float printing
code isn't needed. Better compile time error checking. << is called
the inserter and >> called the extractor overloaded
for all C++ types. You can extend it for your types. Cout << string
writes string to standard out. Cerr uses standard error. << operators
can be concatenated. So
cout << "the data value is " << foo << "\n";
Manipulators act on the iostream. So
cout << flush;
flushes the output from the stream. Others include:
| Endl |
operator outputs newlines. and flushes the output. |
| hex,dec,oct |
change base of output. |
| ws |
eat incoming whitespace. |
To print a number in decimal and then hex:
cout << "in decimal " << num << hex << "in hex " << num << endl;
Cout and cerr by themselves don't output newlines. Cin >> variable reads
from standard in and puts it in var. does formatting. Cin >> string; cin
>> int; Be wary of reading multiple inputs from a line. Example,
1 3.0 this is a string.
would be read as an int, a float and the string 'this' as the spaces are
delimiters. Better to read in a line at a time as characters and then do
conversion.
line input
Two main routines, get() and getline(). Each takes 3 args, pointer
to space to put the input, size of input and delimiter. Stops reading at
delimiter. get doesn't remove the delimiter from the input, getline does.
Neither puts it in the buffer. get with no args returns the next single
char or EOF as an int. get with one reference character parameter put a
char in the variable. There is also a read() member function. First arg
is the destination memory and the second is the number of bytes. There
is a write() function that goes the other way. All iostreams have member
functions to check status. These are good(), bad(), eof() and fail(). The
clear() function can be used to clear an error state indicated by the functions
above. For example, an EOF will indicate both eof and fail. But if you
are seeking around in it, just clear the errors and go on. To read until
EOF, do
while(cin)
{
{ //while
file input
Include fstream.h to use this. Files can be safely opened using file
streams. Closing these is handled by the destructor. Open an input file
with
{
ifstream in("myfile"); // input
assert(in);
ofstream out("myotherfile"); // output
assert(out);
To read a file and print it
while(in.getline(buf,SIZE)) {
cout << buf << endl // standard out
out << buf << endl; //file output
} // while
}
Note that at this point, the file opens go out of scope and are closed
by the destructors. So we can do
{
ifstream in("myotherfile"); // input
ofstream out("mffile"); // output
while(in.getline(buf,SIZE)) {
cout << buf << endl // standard out
out << buf << endl //file output
} // while
}
to copy it back. There is an internal method on streams that allows the
entire contents of the buffer to be dumped. The above code could be replaced
by:
{
ifstream in("myotherfile"); // input
ofstream out("mffile"); // output
out << in.rdbuf();
}
You could also explicitly call the close() member function.
open flags
Just like fopen() in C, you can specify how to open the files using
flags. This table is from page 217 of the text.
| ios::in |
open for input. if used in ofstream, doesn't truncate file |
| ios::out |
open for output. Truncates file. |
| ios::app |
open for appending. |
| ios::ate |
open existing file and seek to end. |
| ios::nocreate |
open only if already exists. |
| ios::noreplace |
open only if it doesn't exist. |
| ios::trunc |
open and delete if it already exists. |
| ios::binary |
opens in binary mode, default is text. |
file positioning
There are two ways to put the file pointer at a particular position
in the file. The Standard C function seek() has an analogue here. There
is also a new technique called streampos a stream pos is a typedef
for a long. A streampos is like a bookmark placed in the stream. the member
function tellp() for ostreams and tellg() for istreams returns a streampos.
These are rather like the tell() function in standard C.
streampos inp = n.tellg()
will return the current byte position within the file.
ifstream in("myfile");
in.seekg(0,ios::end); // seek 0 bytes from the end
streampos sp = in.tellg(); // contains the size of the file
in.seek(-sp/2,ios::end); // seek half way from end
streampos sp2 = in.tellg(); // points to half way mark
// do some other stuff
in.seekg(sp2); // seek back to middle
| ios::beg |
from beginning |
| ios::cur |
from here |
| ios::end |
from end |
string streams
This allows you to use the same I/O techniques on internal memory.
In some ways this is like using sprintf().
istrstream str("hello 2 c");
int i; char b;
char greeting[15];
str >> greeting;
str >> i >> b;
strstream constructors can either take a single argument which is assumed
to be a 0 terminated string or two args, where the second is the size of
the array pointed to by the first. output strstreams have one constructor
that takes three args. They are the pointer to the array to be written
into, the length of that array and the mode. If the mode is missing, the
writing starts at the front of the array. if the mode is either ios::ate
or ios::app, the array is assumed to e a 0 terminated array, and the new
characters are added to the end.
char buffer[32];
ostrstream str(buffer,32,ios::app);
int i=7; char b='c';
char greeting[] = "hello";
str << endl; // initialize
str << i << endl; // add a newline
str << b << endl;
str << greeting << endl;
str << ends; // puts a 0 in the end
automatic storage allocation
If you create an ostrstream without arguments, you get an object where
you don't have to specify the amount of storage.
ostrstream A;
So you can add data to it all day, without worrying about running out of
memory.
A << "hello there" << endl;
A << i << endl;
// more stuff
To print this, you use a trick called streambuffs to access the internal
buffers.
cout << A.rdbuff();
You can get at the actual string by doing
char * strptr = A.str();
However, this closes the strstream and you can't add more characters to
it. This is to prevent the memory pointed to by strptr from becoming invalid,
should the strstream reallocate. There is a way to reopen a strstream,
but we will cover it later. There probably isn't much need to do that.
Compare all this to sprintf() and such.
output formatting
There are member functions on ostreams to do all the things printf()
can do and some others. There are also manipulators to do some of this.
The ios class contains the data to handle the formatting for an ostream.
The member function setf() changes the state of formatting flags. Many
are simple on/off flags but some are more complicated.
| ios::skipws |
skip white space |
| ios::showbase |
indicate the base when printing an integer |
| ios::showpoint |
show decimal point and trailing 0 for floats |
| ios::uppercase |
uppercase hex digits |
| ios::showpos |
show plus for positive integers |
| ios::unitbuf |
flush stream after each insertion |
| ios::stdio |
synchronizes with stdio system |
so
cout.setf(ios::showpos);
turns on the display of + for integers. Turn it off with
cout.unsetf(ios::showpos);
use the ios::stdio flag is your program is doing both iostream and stdio
I/O. and the outputs are appearing in the wrong order. There are groups
of flags that work like radio buttons. Only one can be set. To help this,
since setf(flag) would allow you to set multiple, there are named groups
and a 2 arg version of setf().
| ios:basefield |
|
| ios::dec |
format ints in base 10 |
| ios::hex |
format in hex |
| ios::oct |
format in octal |
| ios::floatfield |
|
| ios::scientific |
use scientific notation on floats |
| ios::fixed |
fixed format for floats |
| neither |
automatic choice |
| ios::adjustfield |
|
| ios::left |
left justify |
| ios::right |
right justify |
| ios::internal |
add fill after sign but before value |
These are set by
cout.setf(ios::hex,ios::basefield);
There are set of functions to set and read the width of fields, the precision
and the fill character.
| int ios::width(),width(int) |
read or set the width of the field |
| int ios::fill(),fill(int) |
read or set the fill character |
| int ios::precision(),precision(int) |
read or set the float precision |
They all return the previous value when set. The width field functions
like the width in the \%s format. It specifies the minimum width.
making manipulators
It is easy to make manipulators of your own. A manipulator like endl
is just a function that takes a ostream as an argument.
ostream& endl(ostream&);
So to make one that outputs a newline but doesn't flush the output,
ostream&
nl(ostream& os)
{
return os << " by kent \n";
} // nl
this can be used just like endl.
count << "here is a string with a newline" << nl;