• C and C++ handle I/O in very different ways
• It is useful to know both, especially since you may wind up working with people that use both

• Streams:
  • A stream can be thought of as a flow (or sequence) of objects (e.g., characters, bytes)
  • Input involves taking objects from the stream
  • Output involves adding objects to the stream
• A Portion of the Class Hierarchy:
  • 
• Common Practice:
  • One generally includes either <iostream> or <fstream>, rather than one of their parents

• Declaration:
  • Exactly the same as with other objects
• Example:
  • ifstream input_file; ofstream output_file;

• Standard In and Out:
  • If you only need to use "console I/O" or "standard in" and "standard out" (which java calls System.in and System.out) you can use the streams cin and cout
• Other Standard Output Files in <iostream>:
  • cerr
  • clog
• Something to Remember:
  • These streams need to be fully-qualified (using std::) or you need to include the statement using namespace std;

• An Example:
  • std::cout << "Hi Mom! \n";
• Some Details:
  • << and >> are operators (more on them shortly)
  • cin is actually an object of type istream_withassign (which is a class that inherits from istream)
  • cout, cerr, clog are actually objects of type ostream_withassign (which is a class that inherits from ostream)

• The Issue:
  • Streams need to be opened before they can be used and closed when you are through with them
  • The standard streams are opened and closed for you
• The Methods:
  • void open(const char *name, int mode)
  • void close(void)
• The Parameters:
  • name is the name of the stream/file
  • mode is the I/O mode

• Approach:
  • Each bit represents a different property
• Flags (defined in the ios class):

  • ios::app	Open for append
    ios::ate	Go to the end
    ios::in	Open for input (required for ifstream)
    ios::out	Open for output (required for ofstream)
    ios::binary	Binary file
    ios::trunc	Discard existing contents

• Using Flags:
  • To set more than one bit, simply OR the appropriate flags together
• An Example:
  • ofstream output_file; output_file.open("sales.dat", (ios::out | ios::app | ios::nocreate) );

int bad()	Returns non-zero if the previous I/O operation failed and data were lost
int good()	Returns non-zero if the previous I/O operation succeeded
int eof()	Returns non-zero if previous read succeeded and the stream is empty
int fail()	Returns non-zero if previous I/O operation failed

• The Insertion Operator (<<):
  • Inserts an ASCII string into a stream (i.e., the left-hand-side operand)
  • If the right-hand operand is not an ASCII string, the insertion operator will attempt to convert it into one
• An Example:
  • std::cout << "Go Dukes!";
• Another Example:
  • int earnings; earnings = 10000; std::cout << "I earned " << earnings << " dollars this month";

• The Extraction Operator (>>):
  • Extracts a sequence of ASCII characters from a stream (i.e., the left-hand-side operand) and converts these characters into one of the built-in data types
• An Example:
  • int orderNumber; cin >> orderNumber;
• Some Details:
  • Consumes and discards any leading whitespace
  • For numeric data, the extraction stops at the first inappropriate character (for the data type)

get	Extract a single character or a string (including whitespace)
getline	Extract a full "line" of characters
ignore	Discards a given number of characters
putback	Inserts a character back into the input stream after it has been read

• Formats:
  • Many applications have to generate output in a particular format and/or read input files that are formatted in a particular way
• Approaches in C++:
  • This can be accomplished by setting format bits or using manipulators

• Methods:
  • setf(int flags)
  • unsetf(int flags)
• Flags (in the ios class):

  • ios::skipws	Skip leading whitespace on input
    ios::left	Left-justify output
    ios::right	Right-justify
    ios::internal	Pad between sign and number on output
    ios::dec	Output in base 10
    ios::oct	Output in base 8
    ios::hex	Output in base 16
    ios::showbase	Include a base indicator on output
    ios::showpoint	Always include a decimal point n output
    ios::uppercase	For hexadecimal digits on output
    ios::showpos	Always include a + or -
    ios::scientific	Output in scientific notation
    ios::fixed	Output as fixed-point numbers

    0x3FF
    

• The Idea:
  • Manipulators are inserted into the stream itself to change the format
• Some Manipulators (in <iomanip>)

  • setiosflags(long flags)	Set the format bits
    resetiosflags(long flags)	Reset the format bits
    ws	Skip whitespace on input
    dec	Output in base 10
    oct	Output in base 8
    hex	Output in base 16
    setw(int width	Set the width of the output
    setprecision(int precision)	Set the precision of floating point output
    setfill(char c)	Set the fill character
    endl	End of line (i.e., '\n')
    ends	End of string (i.e., '\0')

Three spaces and then the two-digit number 12

• The read and write methods:
  • Have two parameters, a pointer to a variable and the size of the item being read (in bytes)
• An Example:
  • inputFile.read(&n, sizeof(n));
  • The sizeof function returns the size (in bytes) of its argument
  • The & operator provides the address of the variable n (more on this later)

• Unix uses one character at the end of lines (i.e., '\n') whereas MS-DOS uses two (i.e., '\r' and '\n')
• Different machines order bytes differently. For example, the short int 0x1234 consists of of two bytes (i.e., 0x12 and 0x34). Some systems write the low-order byte first (e.g., systems with Intel processors) and others write the high-order byte first (e.g., systems with Motorola 68000 processors).
• Some machines limit the addresses that can be used for different data types

• The Concept:
  • It is sometimes convenient to be able to move around in a file without reading from it or writing to it
• Positioning the Read Head ("get pointer"):
  • seekg
• Positioning the Write Head ("put pointer"):
  • seekp

Moves the read head to byte number 300

First moves the read head to the position 100 bytes prior to the end of the file and then moves it 10 bytes forward from that position

• Determining the Current Position:
  • The tellg() and tellp() methods will return the current position of the read and write heads, respectively
• Limitations:
  • Some devices, like the keyboard, are inherently sequential. Hence, they will not support random access