Input/Output Streams

Introduction:

• C++ Standard Libraries provide an extensive set if input/output capabilities
• Many are object oriented
• left-shift operator << is overloaded for stream output and is referred to as the stream insertion operator
• right-shift operator >> is overloaded for stream input and is referred to as the stream extraction operator
• Type-safe I/O - sensitive to the data type
• The compiler generates an error if there is no match between the actual data type and a particular function to handle that type
• Users can customize by overloading the stream insertion operator << and the stream extraction operator >>
• Extensibility

• Remember, an object is a variable which contains data and functions
  • Member Data
  • Member Functions
• An object is declared very similar to a regular variable. A regular variable is declared as:

    typeName variableName;
  

  Since a class is a type (User Defined Type to be exact) it is declared essentially the same way.

    className objectName;
  

  For example: for a class called GradeBook, we could declare:

  
  GradeBook myGradeBook;
  

• To call upon a member function for an object, we use the dot-operator:

    objectName.functionCall
  

  For the GradeBook class, we would call the member function displayMessage in the following manner:

  
  myGradeBook.displayMessage();
  

• This type of syntax is used with stream I/O because the streams are objects
  • cout is the standard output stream, usually representing the monitor. It is of type ostream
  • cin is the standard input stream, usually representing the keyboard. It is of type istream
  • ostream and istream are classes
  • If the above streams were declared manually it could be,

      ostream cout;
      istream cin; 
     

• I/O occurs in streams, or sequence of bytes from source to destination
• Input - bytes flow from device (keyboard, disk drive, network connection, etc) to main memory
• Output - bytes flow from main memory to device (display screen, printer, disk drive, etc)
• System I/O should transfer bytes consistently and reliably
• C++ provides both low-level and high-level I/O cpapbilities
• Low-level or unformatted I/O
  • specifies that some number of bytes should be transferred
  • the individual byte is the unit of interest
  • high-speed, high-volume transfers but not convenient
• High-level or formatted I/O
  • bytes are grouped into meaningful units
  • integers, floats, characters, strings, user-defined types
  • ok for most I/O except high-volume processing

            ios_base
               |
              ios
            /     \
      istream      ostream
       |    \      /   |
       |    iostream   |
       |       |       |
ifstream    fstream    ofstream

• Most C++ programs include the <iostream> header
• Defines cin, cout, cerr and clog objects
• cin is the standard input stream
• cout is the standard output stream
• cerr is an unbuffered standard error stream
• clog is a buffered standard error stream

• All of the standard library classes are in the std namespace.
• All of the stream classes are derived from base class ios_base
• For familiarization we will look at portions of ios_base and istream below

Class ios_base

namespace std
{
  class ios_base 
  {
  public:
    // ios_base status methods
    // these read and/or manipulate the status bits
    bool  fail () const; // true iff bad or fail state 
    bool  eof  () const; // true iff stream is at end of file
    ...
    // ios_base binding methods
    ostream*  tie (ostream*);   // ties current stream to specified ostream
    ...
    // ios_base formatting methods
    format_flags setf (format_flags flags);
    ...
    // ios_base data methods
    int  width(int val);
    char fill (char fillch);
    ...
    // ios_base enumerated bitmask types
    enum iostate     { ... }; // 4 io states, representing good, eof, bad, fail
    enum formatflags { ... }; // 15 format flags, such as left, showpoint, hex
    enum openmode    { ... }; // 6 file open modes, such as in, out, binary
    enum seekdir     { ... }; // 3 file seek modes: beg, cur, end

  protected:
    unsigned long state;          // stores status bits
    unsigned long flags;          // stores flag bits
    unsigned long mode;           // stores mode bits
    int           widthvalue,     // initialized to 0
                  precisionvalue; // initialized to 0
    char          fillcharacter;  // initialized to ' '
    streambuff*   streambuffer;   // pointer to a streambuff object

    // plus other data, such as specifying tied streams
  }  ;  // end pseudo-definition of class ios_base
} // namespaced std

Class istream

namespace std
{
  class istream : public class ios_base
  {
    // overloads of input operator
    friend istream& operator >> (istream& , char);
    friend istream& operator >> (istream& , int);
    friend istream& operator >> (istream& , long);
    friend istream& operator >> (istream& , unsigned char);
    friend istream& operator >> (istream& , unsigned int);
    friend istream& operator >> (istream& , unsigned long);
    friend istream& operator >> (istream& , float);
    friend istream& operator >> (istream& , double);
    friend istream& operator >> (istream& , long double);
    friend istream& operator >> (istream& , char* );
    ...
    public:
      // methods to access next element in stream
      char get ();  
      void get (char&);
      char peek ();
      ...
  } cin;  // predefined object
} // namespace std

Standard I/O Devices

Utilizing Input/Output:

• Use iostream to extract (receive) data from keyboard and send output to the screen
• IOstream contains definitions of two types:
1. istream - input stream
2. ostream - output stream
• Basic IOstream variables:
1. cin - common input
2. cout - common output
3. cerr - standard output stream for errors

cin and cout

Using cin and cout:

• To use cin and cout, the preprocessor directive #include <iostream> must be used
• The declaration is similar to the following C++ statements:

istream cin;
ostream cout;

• Input stream variables: type istream
• Output stream variables: type ostream

cin and Extraction Operator ( >> )

Syntax of input statement using cin and extraction operator ( >> ):

cin >> variable >> variable...;

• Extraction operator >> is binary operator
• Overloaded right-shift operator
• Left-hand operand is input stream variable (e.g., cin)
• Right-hand operand is variable of simple data type (e.g., myNum)

Standard Input

Using Standard Input:

• Every occurrence of >> extracts the next data item from the input stream
• Two variables can be read using a single cin statement
• No difference between a single cin with multiple variables and multiple cin statements with one variable
• When scanning, >> skips all whitespace
• Whitespace characters consist of blanks and certain nonprintable characters

Data Type of Input

Extraction Operator ( >> ) distinguishes between character 2 and number 2 by right hand operand:

• If type char, 2 treated as character 2
• If type int (or float or double) 2 treated as number 2

Reading Data

Reading data into a char variable:

• Extraction operator >> skips leading whitespace, finds and stores only next character
• Reading stops after single character

• Extraction operator >> skips leading whitespace, reads plus or minus sign (if any), reads digits (including decimal)
• Reading stops on whitespace non-digit character

int a, b;
double z;
char ch;

Statement		Input		Value Stored in Memory
1 cin >> ch;		A		ch = 'A'
2 cin >> ch;		AB		ch = 'A', 'B' held for later input
3 cin >> a;		48		a = 48
4 cin >> a;		46.35		a = 46, .35 held for later input
5 cin >> z;		74.35		z = 74.35

int n;

char str [max];

 /*
The following code skips white space (including end of line) to next
visible char, then reads characters as long as they can be made into
an integer (optional +/- followed by digits), then builds an int from
this and puts the value into n
*/

std::cin >> n;

 /*
The following code skips white space to next visible char, then reads
characters up to the next white space char, then builds a string from
this input and puts the value into str
*/

std::cin >> str; 

int n;
while (std::cin >> n)
{
  // do whatever appropriate with n, which is ensured to be of type int
}
// after all ints are read, execution picks up here

int n;
while (std::cin >> n >> str) // read an integer and then a string
{
  // do whatever appropriate with n and str
}
// after all integer, string pairs are read, execution picks up here

Input Failure

Input Failure Issues:

• Input data does not match associated variables
• Inputting a letter into an int or double variable - input failure
• If error occurs when reading data: input stream enters fail state
• In fail state, all further I/O statements using that stream are ignored
• However, program continues to execute with values previously stored in variables, if any
• Input failure can be used to your advantage to end input
• For example, a char can be used to end reading int's
• if a char is input when expecting int's subsequent entries are ignored
• Previous input values are ok
• If failure is undesired, program may return unexpected results
• Syntax of clear() function:

istreamVar.clear(); // clear function restores input stream to working state

Predefined Functions

Using Predefined Functions (see Ch 6):

• Function (subprogram): set of instructions
• When activated, accomplishes a task
• main executes when a program is run
• Other functions execute only when called
• C++ includes many functions
• Predefined functions organized as collection of libraries called header files
• Header file may contain several functions
• To use a predefined function, need name of appropriate header file
• Also need to know:
• Function name
• Number of parameters required
• Type of each parameter
• What function will do

• To use pow (power), include cmath
• pow has two numeric parameters
• The syntax is: pow(x,y) = x^y
• x and y are the arguments or parameters
• In pow(2,3), the parameters are 2 and 3

This isn't necessarily efficient, but simply an example of using the methods.
Turns any exclamation marks (!) into dollar signs ($) and removes any pound symbols (#)

  // Using peek() and putback()
  #include <iostream.h>

  using namespace std;  

  int main()
  {
     char ch;
     cout << "enter a phrase: ";
     while ( cin.get(ch) )
     {
        if (ch == '!')
           cin.putback('$');
        else
           cout << ch;
        while (cin.peek() == '#')
           cin.ignore(1,'#');
     }
     return 0;
  }

  Output: enter a phrase: Now!is#the!time#for!fun#!
  Now$isthe$timefor$fun$
  

• get() function:
• Up to three parameters
• With no arguments, inputs next character (including whitespace)
• With one character reference argument, gets the next character and stores it in the character argument
• Three argmuments, a character array, a size limit, and a delimiter. Default delimiter is '\n'.

     while ( cin.get(ch) )
    

• Figure 15.5

• ignore() function:
• Discards portion of input
• Takes two arguments - the designated number of characters to ignore and the delimiter
• Syntax for cin and ignore() function:
• cin.ignore(intExp, chExp);
• intExp is an integer expression
• chExp is a char expression
• When intExp contains value n, statement will ignore next n characters or all characters until character specified by chExp

    cin.ignore(1,'#');
    

• Typically used for parsing strings or other data
• putback() function:
• Places previous character extracted by get function from input stream back to that stream
• Takes one argument
• Syntax for putback() function:
• istreamVar.putback(ch);
• istreamVar - input stream variable (e.g., cin)
• ch is char variable
• Takes one argument
• Takes NO argument

    cin.putback(`$');
  

• peek() function:
• Returns next character from input stream
• Does not remove character from that stream
• Takes NO argument
• Syntax for peek() function:
• ch = istreamVar.peek();
• istreamVar - input stream variable (e.g., cin)
• ch is char variable
• Takes NO argument

    while (cin.peek() == `#')
  

• In C++, dot is called member access operator
• Dot separates input stream variable name from member or function name

cin.get(ch); //cin and get() are two separate identifiers separated by dot

Standard Output - Member Functions and Flags

Output streams (class ostream and related classes) have some useful member functions for controlling output formatting.
Here are a few:

• setf() -- the "set flags" function. Takes as a parameter the flag to be turned "on". Some of the flags that can be turned on or off are:
  • ios::fixed -- to specify that floating-point numbers will be printed in fixed notation.
  • ios::scientific -- to specify that floating-point numbers will be printed in scientific (exponential) notation.
  • ios::showpoint -- specifies that the decimal point will always be printed for floating point types (even if the value is a whole number, like 4.0
  • ios::right -- right-justifies an output item in a field, if a field width is specified
  • ios::left -- left-justifies an output item in a field, if a field width is specified
  • See the table below for more formatting flags
• unsetf() -- the "unset flags" function. Call this to turn off one of the flags
• precision() -- sets the precision for floating-point values to a specific number of significant digits after the decimal point. Takes that number as a parameter
• width() -- used to specify the "field width" for the next item that is output. Number of character positions is specified as a parameter. Left and right justify flags will apply when this function is used to specify field widths. Extra "space" in the field will be filled with a fill character, which is set to a space by default:

    int x = 1234;
    cout.setf(ios::right);
    cout.width(10);
    cout << "Hello";
    cout.width(15);
    cout << x;
  
    // output of the above is:
    //      Hello           1234
  

• fill() -- used to specify the fill character to be used to pad out extra space in a field (when using width()). Takes the character as a parameter.

    int x = 1234;
    cout.setf(ios::right);
    cout.fill('.');// change the fill character
    cout.width(10);// set field width to 10
    cout << x;// print x
  
    // output of the above is:
    // ......1234
  

Standard Output - Stream Manipulators

Using and Formatting Standard Output:

• Many of the stream manipulators are just alternate ways of doing tasks performed by member functions.
  A nice benefit is that cascading can be used, intermixing manipulators and other output statements
  that use the insertion operator

   cout << setw(10) << "Hello" << endl;
  

• A stream manipulator is a symbol or function that is used by placing it on the right side of the insertion operator << .
• Syntax of cout with insertion operator ( << )

cout << expression or manipulator(s)...;

• Expression evaluated
• Value printed
• Manipulator(s) used to format output

• Two types of manipulators: with parameters, without parameters
• Parameterized:
• include <iomanip> library (i.e., setprecision, setw, and setfill)
• looks like a function call -- it has one or more parameters:

  cout << setw(10); // setw() is a parameterized manipulator

• Nonparameterized:
  • include <iostream> library (i.e., endl, fixed, showpoint, left, and flush)
  • similar to using a variable

    cout << endl;

• Nonparameterized
• endl manipulator moves output to beginning of next line

  cout << endl;

• setprecision(n)
  • outputs decimal numbers up to n decimal places (Figure 15.9)
  • parameterized stream manipulator that performs the same task as the member function precision()

       cout.precision(2);   // sets decimal precision to 2 significant digits
       cout << setprecision(2);  // does the same thing!
      

• fixed
• non-parameterized
• outputs floating-point numbers in fixed decimal format (Figure 15.18)
• showpoint
• Non-parameterized
• forces output to show decimal point and trailing zeros (Figure 15.13)

• parameterized stream manipulator
• performs the same task as the member function width()

   cout.width(10);   // sets field width to 10 for next output
   cout << setw(10);         // same functionality
  

• outputs value of expression in specific columns
• If number of columns exceeds number of columns required by expression - output right-justified
• Unused columns to left filled with spaces

• flush clears buffer--even if not full
• Unlike endl, does not move cursor to beginning of next line
• Syntax for flush manipulator:

ostreamVar << flush; // ostreamVar is output stream variable

• Output stream variables can use setfill manipulator to fill unused columns with a particular character
• left
• left-justifies output
• Disable left by using unsetf
• Syntax for left manipulator:

  ostreamVar << left;
  

• right
• right-justifies the output
• Disable right by using unsetf
• Syntax for right manipulator:

  ostreamVar << right;
  

• Figure 15.14

Common Stream Flags and Manipulators

Here is a table of common stream flags and corresponding stream manipulators (non-parameterized, and all from namespace std).
 

cout << "12345678901234567890" << endl;
cout << fixed << showpoint << setprecision(2);
cout << setfill (' ') << setw (10) << 1.234 << '\n';

12345678901234567890
      1.23

/*
This program demos formatting output using setw(), setfill(), fixed, showpoint,
and setprecision()
 written by Mark K. Jowett, Ph.D.
10:46 PM 6/16/9
*/

#include <iostream>
using std::cout; //standard output
using std::cin; //standard input
using std::endl; //end line
using std::right; //right-justified
using std::left; //left-justified

#include <iomanip>
using std::fixed; //write floating point values in fixed-point notation.
using std::scientific; //write floating point values in scientific notation.
using std::showpoint; //decimal point always written for floating point values
using std::setprecision; //sets decimal precision used by output 
using std::setfill; //Sets fill character to value of parameter. 
using std::setw; //Sets number of characters to be used as the field width for
the next insertion operation.

int main()
{
    int a = 19;
    int b = 345;
    double c = 76.384;

    cout << "Demo fixed, showpoint, setprecision(), setw()...\n";

    cout << fixed << showpoint;
    cout << "12345678901234567890" << endl;

    cout << setw(5) << a << endl;
    cout << setw(5) << b << setw(5) << "Hi"
         << setw(5) << a << endl << endl;
	 
    cout << setprecision(2);
    cout << setw(6) << b << setw(6) << c
         << setw(6) << a << endl;
    cout << setw(6) << a << setw(6) << b
         << setw(6) << c << endl << endl;

    cout << setw(5) << b << a << endl;
    cout << setw(2) << b << setw(4) << a << endl;

    cout << "\nDemo setfill(), setw()...\n";
    int i = 20;
    int j = 5678;

    cout << "12345678901234567890" << endl;
    cout << setw(5) << i << setw(7) << j
         << setw(8) << "Test" << endl;

    cout << setfill('*');
    cout << setw(5) << i << setw(7) << j
         << setw(8) << "Test" << endl;

    cout << setw(5) << i << setw(7) << setfill('#')
         << j << setw(8) << "Test" << endl;

    cout << setw(5) << setfill('@') << i
         << setw(7) << setfill('#') << j
         << setw(8) << setfill('^') << "Test" << endl;

    cout << setfill(' ');
    cout << setw(5) << i << setw(7) << j
         << setw(8) << "Test" << endl;

    cout << "\nDemo setfill(), setw(), left-justified...\n";
    int x = 20;
    int y = 5678;
  
    cout << left;

    cout << "12345678901234567890" << endl;
    cout << setw(5) << x << setw(7) << y
         << setw(8) << "Test" << endl;

    cout << setfill('*');
    cout << setw(5) << x << setw(7) << y
         << setw(8) << "Test" << endl;

    cout << setw(5) << x << setw(7) << setfill('#')
         << y << setw(8) << "Test" << endl;

    cout << setw(5) << setfill('@') << x
         << setw(7) << setfill('#') << y
         << setw(8) << setfill('^') << "Test" << endl;

    cout << setfill(' ');
    cout << setw(5) << x << setw(7) << y
         << setw(8) << "Test" << endl;

    cout << "\nDemo setfill(), setw(), right-justified...\n";
    cout << right;

    cout << "12345678901234567890" << endl;
    cout << setw(5) << x << setw(7) << y
         << setw(8) << "Test" << endl;

    cout << setfill('*');
    cout << setw(5) << x << setw(7) << y
         << setw(8) << "Test" << endl;

    cout << setw(5) << x << setw(7) << setfill('#')
         << y << setw(8) << "Test" << endl;

    cout << setw(5) << setfill('@') << x
         << setw(7) << setfill('#') << y
         << setw(8) << setfill('^') << "Test" << endl;

    cout << setfill(' ');
    cout << setw(5) << x << setw(7) << y
         << setw(8) << "Test" << endl;

    cout << "\nDemo aligning numbers setfill(), setw(), right-justified...\n";
    double z = 1234.5678;

    cout << "12345678901234567890" << endl;
    cout << right;
    cout << setprecision(2);
    cout << setfill ('-') << setw (10) << 1.234 << '\n';

    cout << setprecision(2);
    cout << setfill ('-') << setw (10) << z << endl;

    cout << setprecision(3);
    cout << setfill ('-') << setw (10) << z << endl;

    cout << setprecision(4);
    cout << setfill ('-') << setw (10) << z << endl;

    cout << "\nDemo aligning numbers setfill(), setw(), left-justified...\n";
    cout << left;
    cout << setprecision(2);
    cout << setfill ('-') << setw (10) << 1.234 << '\n';

    cout << setprecision(2);
    cout << setfill ('-') << setw (10) << z << endl;

    cout << setprecision(3);
    cout << setfill ('-') << setw (10) << z << endl;

    cout << setprecision(4);
    cout << setfill ('-') << setw (10) << z << endl;

    cout << "Press Enter key to exit...";
    cin.get(); // make DOS window stay open

    return 0;
}

Demo fixed, showpoint, setprecision(), setw()...
12345678901234567890
   19
  345   Hi   19

   345 76.38    19
    19   345 76.38

  34519
345  19

Demo setfill(), setw()...
12345678901234567890
   20   5678    Test
***20***5678****Test
***20###5678####Test
@@@20###5678^^^^Test
   20   5678    Test

Demo setfill(), setw(), left-justified...
12345678901234567890
20   5678   Test
20***5678***Test****
20***5678###Test####
20@@@5678###Test^^^^
20   5678   Test

Demo setfill(), setw(), right-justified...
12345678901234567890
   20   5678    Test
***20***5678****Test
***20###5678####Test
@@@20###5678^^^^Test
   20   5678    Test

Demo aligning numbers setfill(), setw(), right-justified...
12345678901234567890
------1.23
---1234.57
--1234.568
-1234.5678

Demo aligning numbers setfill(), setw(), left-justified...
1.23------
1234.57---
1234.568--
1234.5678-
Press Enter key to exit...