| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
Here s an example that shows many of the features discussed
so far. Notice the inclusion of <fstream> to declare the file I/O classes. Although on many platforms this will also include <iostream>
automatically, compilers are not required to do so. If you want portable code,
always include both headers.
//: C04:Strfile.cpp
// Stream I/O with files;
// The difference between get() & getline().
#include <fstream>
#include <iostream>
#include "../require.h"
using namespace std;
int main() {
const int SZ = 100; // Buffer size;
char buf[SZ];
{
ifstream in("Strfile.cpp"); // Read
assure(in, "Strfile.cpp"); // Verify open
ofstream out("Strfile.out"); // Write
assure(out, "Strfile.out");
int i = 1; // Line counter
// A less-convenient approach for line input:
while(in.get(buf, SZ)) { // Leaves \n in input
in.get(); // Throw away next character (\n)
cout << buf << endl; // Must add \n
// File output just like standard I/O:
out << i++ << ": " <<
buf << endl;
}
} // Destructors close in & out
ifstream in("Strfile.out");
assure(in, "Strfile.out");
// More convenient line input:
while(in.getline(buf, SZ)) { // Removes \n
char* cp = buf;
while(*cp != ':')
++cp;
cp += 2; // Past ": "
cout << cp << endl; // Must still add
\n
}
} ///:~
The creation of both the ifstream and ofstream
are followed by an assure( ) to guarantee the file was successfully
opened. Here again the object, used in a situation where the compiler expects a
Boolean result, produces a value that indicates success or failure.
The first while loop demonstrates the use of two
forms of the get( ) function. The first gets characters into a
buffer and puts a zero terminator in the buffer when either SZ-1
characters have been read or the third argument (defaulted to '\n') is
encountered. The get( ) function leaves the terminator character in
the input stream, so this terminator must be thrown away via in.get( )
using the form of get( ) with no argument, which fetches a single
byte and returns it as an int. You can also use the ignore( )
member function, which has two default arguments. The first argument is the
number of characters to throw away and defaults to one. The second argument is
the character at which the ignore( ) function quits (after
extracting it) and defaults to EOF.
Next, you see two output statements that look similar: one
to cout and one to the file out. Notice the convenience here you don t
need to worry about the object type because the formatting statements work the
same with all ostream objects. The first one echoes the line to standard
output, and the second writes the line out to the new file and includes a line
number.
To demonstrate getline( ), open the file we just
created and strip off the line numbers. To ensure the file is properly closed
before opening it to read, you have two choices. You can surround the first
part of the program with braces to force the out object out of scope,
thus calling the destructor and closing the file, which is done here. You can
also call close( ) for both files; if you do this, you can even
reuse the in object by calling the open( ) member function.
The second while loop shows how getline( )
removes the terminator character (its third argument, which defaults to '\n')
from the input stream when it s encountered. Although getline( ),
like get( ), puts a zero in the buffer, it still doesn t insert the
terminating character.
This example, as well as most of the examples in this
chapter, assumes that each call to any overload of getline( ) will
encounter a newline character. If this is not the case, the eofbit state of the
stream will be set and the call to getline( ) will return false,
causing the program to lose the last line of input.
| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
