Chapter 12: Streams I

Chapter Goals

• To be able to read and write files
• To convert between strings and numbers using string streams

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
• You must include the header file fstream to use file variables.
• 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 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 - use input_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 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 read_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.
• The string stream classes have the same interface as the other stream classes (stream operators << and >>, member functions put and get etc.)
  
• 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 comma.
  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 (input.substr(8,2) returns "23").
  
• 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

String Streams (readtime.cpp)