Streams

Chapter 12: Streams I

Chapter Goals

To be able to read and write files
To convert between strings and numbers using string streams
To learn how to process the command line
To understand the concepts of sequential and random access
To be able to build simple random-access database files
To learn about encryption

Reading and Writing Text Files

To access a disk file, you need to open a file variable.
- type ifstream for input
```
ifstream input_data;
```
- type ofstream for output
- type fstream for both input and output
To read anything from a file, you need to open it.
```
input_data.open("input.dat");
```
To read from the file, use the name of the ifstream variable in place of cin.
```
int n;
double x;
input_data >> n >> x;
```

You read in strings in the usual way.

string s;
input_data >> s; /* read a word */
getline(input_data, s); /* read a line */

You read in a single character with a get method.
```
char ch;
input_data.get(ch);
```

If you read a character and you regretted it, you can unget it, so that the next input operation can be read again.

char ch;
input_data.get(ch);
if ('0' <= ch && ch <= '9') /* it was a digit */
{  input_data.unget(); /* oops - didn't want to read it */
   int n;
   input_data >> n; /* read integer starting with ch */
}

This is called one-character lookahead: at the next character in the input stream you can make a decision what you want to read in next, but not more than one character.
Older implementations of the stream library do not have the unget member function - useinput_data.put_back(ch) instead.
When you are done using a file, you should close it.
```
input_data.close();
```

Writing to a file is similar.

Open a file for writing.

ofstream output_data;
output_data.open("output.dat");

Send information to the file in the usual way.
```
output_data << n << " " << x << "\n";
```
To write a single character to a file use
```
output_data.put(ch);
```
When you are done, remember to close the file.
```
output_data.close();
```

Older implementations of the stream library may require a second parameter to open a file.
```
datafile.open("employee.dat", ios::in | ios::out).
```

The file name that you give the open command may be a string constant

input_data.open("input.dat");

or a string variable that contains a file name.

string input_name =
   cwin.get_string("Please enter the file name:");
ifstream input_data;
input_data.open(input_name);

Many compilers don't support string parameters for the open function, so you must use the c_str function to convert the parameter to a character array.
```
input_data.open(input_name.c_str());
```
File names can contain directory path information, but you must supply the escape character for a backslash.
```
input_data.open("c:\\homework\\input.dat");
```
Always pass streams by reference!!

Reading and Writing Text Files (`maxval1.cpp`)

The Inheritance Hierarchy of Stream Classes

The C++ input/output library consists of several classes that are related by inheritance.

The standard cin and cout objects belong to specialized system-dependent classes with nonstandard names.
You can assume that cin belongs to a class that is derived from istream and cout belongs to a class derived from ostream.
Take advantage of the inheritance relationships between the stream classes whenever you write functions with stream parameters.
```
double rand_data(istream& in);
```
You can now pass parameters of types derived from istream, such as a ifstream object or cin.
```
max = read_data(infile);
max = read_data(cin);
```
Remember to pass the streams by reference to avoid slicing.

The Inheritance Hierarchy of Stream Classes (`maxval2.cpp`)

String Streams

The istringstream class (#include<sstream>) reads characters from a string, and the ostringstream class writes characters to a string.

Using an istringstream, you can read numbers that are stored in a string by using the >> operator.

string input = "January 23, 1955";
istringstream instr(input);
string month;
int day;
string commma.
int year;
instr >> month >> day >> comma >> year;

Note that this input statement yields a day and year as integers. Had we taken the string apart with substr, we would have obtained only strings.
Converting strings that contain digits to their integer values is such a common operation that it is useful to write a helper function for that purpose.
```
int string_to_int(string s)
{
   istringstream instr(s);
   int n;
   instr >> n;
   return n;
}
```

By writing to a string stream, you can convert numbers to strings.
```
ostringstream outstr;
```
By using the << operator, the number is converted into a sequence of characters.
```
outstr << setprecision(5) << sqrt(2);
```
To obtain a string from the stream, call the str member function.
```
string output = outstr.str();
```

Example: (builds the string "January 23, 1955")

string month = "January";
int day = 23;
int year = 1955;
ostringstream outstr;
outstr << month << " " << day << "," << year;
string output = outstr.str();

Converting an integer into a string is such a common operation that is useful to have a helper function for it.
```
string int_to_string(int n)
{
   ostringstream outstr;
   outstr << n;
   return outstr.str();
}
```

A very common use of string streams is to accept input one line at a time and then to analyze it further.
A typical example is when the program accepts input in a variety of formats.
```
21:30
9:30 pm
9 am
```
See readtime.cpp.

Chapter 12: Streams I

Chapter Goals

Reading and Writing Text Files

Reading and Writing Text Files (maxval1.cpp)

The Inheritance Hierarchy of Stream Classes

The Inheritance Hierarchy of Stream Classes (maxval2.cpp)

String Streams

String Streams (readtime.cpp)

Reading and Writing Text Files (`maxval1.cpp`)

The Inheritance Hierarchy of Stream Classes (`maxval2.cpp`)

String Streams (`readtime.cpp`)