Like C, C++ does not have built-in input/output capability. All C++ compilers, however, come bundled with a systematic, object-oriented I/O package, known as the iostream classes. The stream is the central concept of the iostream classes. You can think of a stream object as a smart file that acts as a source and destination for bytes. A stream's characteristics are determined by its class and by customized insertion and extraction operators.
Through device drivers, the disk operating system deals with the keyboard, screen, printer, and communication ports as extended files. The iostream classes interact with these extended files. Built-in classes support reading from and writing to memory with syntax identical to that for disk I/O, which makes it easy to derive stream classes.
TianJin university , 300072
TianJin ,China
Msn: [email protected] QQ:286259397
OutputStreams
An output stream object is a destination for bytes. The three most important output stream classes are ostream, ofstream, and ostrstream.
The ostream class, through the derived class basic_ostream, supports the predefined stream objects:
-
cout standard output
-
cerr standard error with limited buffering
-
clog similar to cerr but with full buffering
Objects are rarely constructed from ostream; predefined objects are generally used. In some cases, you can reassign predefined objects after program startup. The ostream class, which can be configured for buffered or unbuffered operation, is best suited to sequential text-mode output. All functionality of the base class, ios, is included in ostream. If you construct an object of class ostream, you must specify a streambuf object to the constructor.
The ofstream class supports disk file output. If you need an output-only disk, construct an object of class ofstream. You can specify whether ofstream objects accept binary or text-mode data when constructing the ofstream object or when calling the open member function of the object. Many formatting options and member functions apply to ofstream objects, and all functionality of the base classes ios and ostream is included.
If you specify a filename in the constructor, that file is automatically opened when the object is constructed. Otherwise, you can use the open member function after invoking the default constructor.
Like the run-time function sprintf, the ostrstream class supports output to in-memory strings. To create a string in memory using I/O stream formatting, construct an object of class ostrstream. Because ostrstream objects are write-only, your program must access the resulting string through a pointer to char.
You can construct an output file stream in one of two ways:
Use the default constructor, and then call the open member function.
ofstream myFile;
//
Static or on the stack
myFile.open(
"
filename
"
);ofstream
*
pmyFile
=
new
ofstream;
//
On the heap
pmyFile
->
open(
"
filename
"
); //Specify a filename and mode flags
in
the constructor call. ofstream myFile(
"
filename
"
, ios_base::
out
);
To construct an output string stream, you can use one of two ostrstream constructors. One dynamically allocates its own storage, and the other requires the address and size of a preallocated buffer.
The dynamic constructor is used in the following way:
char
*
sp;ostrstream myString;mystring
<<
"
this is a test
"
<<
ends;sp
=
myString.str();
//
Get a pointer to the string
The ends "manipulator" adds the necessary terminating null character to the string.
The constructor that requires the preallocated buffer is used in the following way:
char
s[
32
];ostrstream myString( s,
sizeof
( s ) );myString
<<
"
this is a test
"
<<
ends;
//
Text stored in s
Input Streams :
An input stream object is a source of bytes. The three most important input stream classes are istream, ifstream, and istrstream.
The istream class is best used for sequential text-mode input. You can configure objects of class istream for buffered or unbuffered operation. All functionality of the base class, ios, is included in istream. You will rarely construct objects from class istream. Instead, you will generally use the predefined cin object, which is actually an object of class ostream. In some cases, you can assign cin to other stream objects after program startup.
The ifstream class supports disk file input. If you need an input-only disk file, construct an object of class ifstream. You can specify binary or text-mode data. If you specify a filename in the constructor, the file is automatically opened when the object is constructed. Otherwise, you can use the open function after invoking the default constructor. Many formatting options and member functions apply to ifstream objects. All functionality of the base classes ios and istream is included in ifstream.
Like the library function sscanf, the istrstream class supports input from in-memory strings. To extract data from a character array that has a null terminator, allocate and initialize the string, then construct an object of class istrstream.
If you are using an input file stream (ifstream), you must associate that stream with a specific disk file. You can do this in the constructor, or you can use the open function. In either case, the arguments are the same.
You generally specify an ios_base::openmode flag when you open the file associated with an input stream (the default mode is ios::in). For a list of the open_mode flags, see The open Function. The flags can be combined with the bitwise OR ( | ) operator.
To read a file, first use the fail member function to determine whether it exists:
if ( ifile.fail() )
// The file does not exist ...
The Get Function:
The unformatted get member function works like the >> operator with two exceptions. First, the get function includes white-space characters, whereas the extractor excludes white space when the skipws flag is set (the default). Second, the get function is less likely to cause a tied output stream (cout, for example) to be flushed.
A variation of the get function specifies a buffer address and the maximum number of characters to read. This is useful for limiting the number of characters sent to a specific variable, as this example shows:
/
ioo_get_function.cpp
//
compile with: /EHsc
//
Type up to 24 characters and a terminating character.
//
Any remaining characters can be extracted later.
#include
<
iostream
>
using
namespace
std;
int
main()
{
char line[25]; cout << " Type a line terminated by carriage return\n>"; cin.get( line, 25 ); cout << line << endl;
}
Input
1234
Sample Output
1234
The getline Function
The getline member function is similar to the get function. Both functions allow a third argument that specifies the terminating character for input. The default value is the newline character. Both functions reserve one character for the required terminating character. However, get leaves the terminating character in the stream and getline removes the terminating character.
The following example specifies a terminating character for the input stream:
//
getline_func.cpp
//
compile with: /EHsc
#include
<
iostream
>
using
namespace
std;
int
main( )
{ char line[100]; cout << " Type a line terminated by 't'" << endl; cin.getline( line, 100, 't' ); cout << line;}
Input test
The close Function for Input Streams
The close member function closes the disk file associated with an input file stream and frees the operating system file handle. The ifstream destructor closes the file for you, but you can use the close function if you need to open another file for the same stream object.
[reference: MSDN & Some other books about C++ Basic]