Ch 7. Stream Computation

6 hours · 8 marks

7.1 Input/Output Stream Class Hierarchy

A stream is an abstraction representing a flow of data (bytes) between a program and a device (console, file, memory). C++ I/O is built around a class hierarchy in <iostream>:

• ios — base class holding common stream state/formatting flags.
• istream — handles input (cin, >>, get(), getline()).
• ostream — handles output (cout, <<, put()).
• iostream — inherits both istream and ostream for bidirectional streams.
• ifstream, ofstream, fstream (from <fstream>) — file input, file output, and bidirectional file streams respectively, derived from istream/ostream/iostream.

Predefined objects: cin (standard input), cout (standard output), cerr (unbuffered standard error), clog (buffered standard error).

7.2 Testing Stream Errors

Each stream maintains state flags checked via member functions:

int x;
cin >> x;
if (cin.fail()) { cout << "Invalid input"; cin.clear(); }

7.3 Unformatted and Formatted I/O

Unformatted I/O works with raw characters/bytes without interpretation — e.g., get(), put(), getline(), read(), write().

Formatted I/O interprets data according to type and formatting rules, using >>/<< along with manipulators (setw, setprecision, fixed) to control width, precision, base, and alignment.

#include <iomanip>
cout << setw(10) << setfill('*') << 42 << endl;    // formatted
cout << fixed << setprecision(2) << 3.14159 << endl; // 3.14

char ch;
cin.get(ch);                 // unformatted single character input
cout.put('A');                // unformatted single character output

7.4 Stream Operator Overloading

The insertion (<<) and extraction (>>) operators can be overloaded for user-defined classes so objects can be directly written to/read from streams. Because the left operand is a stream object (ostream/istream), these MUST be overloaded as non-member (usually friend) functions.

class Point {
    int x, y;
public:
    Point(int a=0, int b=0): x(a), y(b) {}
    friend ostream &operator<<(ostream &out, const Point &p) {
        out << "(" << p.x << ", " << p.y << ")";
        return out;                 // returning ostream& allows chaining: cout << p1 << p2;
    }
    friend istream &operator>>(istream &in, Point &p) {
        in >> p.x >> p.y;
        return in;
    }
};
int main() {
    Point p;
    cin >> p;
    cout << p;
}

7.5 File Input/Output with Streams

File streams (from <fstream>) let a program read from or write to files on disk, using the same <</>> syntax as console I/O.

#include <fstream>
ofstream fout("data.txt");     // open for writing (creates/truncates file)
fout << "Hello File";
fout.close();

ifstream fin("data.txt");       // open for reading
string line;
getline(fin, line);
fin.close();

7.6 File Stream Class Hierarchy

• ofstream — derived from ostream, for writing to files.
• ifstream — derived from istream, for reading from files.
• fstream — derived from iostream, for both reading and writing.

All three ultimately derive from the common base ios, inheriting formatting and error-state functionality.

7.7 ASCII and Binary Files

ofstream fout("data.bin", ios::binary);
fout.write(reinterpret_cast<char*>(&obj), sizeof(obj));

7.8 Read/Write from File

struct Record { int id; char name[20]; };
Record r = {1, "Ram"};
ofstream fout("rec.dat", ios::binary);
fout.write((char*)&r, sizeof(r));
fout.close();

Record r2;
ifstream fin("rec.dat", ios::binary);
fin.read((char*)&r2, sizeof(r2));
fin.close();

7.9 Sequential Access to File

Data is read/written in order from beginning to end, one record after another — simplest and most common access mode, suitable when records are always processed in order.

7.10 Random Access to File

Allows jumping directly to any position in the file without reading everything before it, using file pointer manipulation functions (seekg/seekp) combined with fixed-size records.

fstream file("rec.dat", ios::in | ios::out | ios::binary);
file.seekg(2 * sizeof(Record));   // jump directly to the 3rd record (index 2)
file.read((char*)&r, sizeof(r));

7.11 File Access Pointers and Their Manipulators

• seekg(pos) — moves the get (read) pointer to a position.
• seekp(pos) — moves the put (write) pointer to a position.
• tellg() — returns the current position of the read pointer.
• tellp() — returns the current position of the write pointer.
• Seek direction flags: ios::beg (from beginning), ios::cur (from current position), ios::end (from end) — e.g. file.seekg(-10, ios::end);

7.12 Testing Errors During File Operations

ifstream fin("nofile.txt");
if (!fin) { cout << "File could not be opened"; }   // uses overloaded operator!
if (fin.is_open()) { ... }
if (fin.fail()) { ... }

7.13 File I/O with Member Functions

Instead of overloaded operators, file streams offer explicit member functions for finer control: open(), close(), is_open(), read(), write(), get(), put(), getline(), eof().

fstream f;
f.open("data.txt", ios::out);
if (f.is_open()) { f << "text"; f.close(); }

Most Probable Questions

#include <fstream>
#include <iostream>
using namespace std;
class Student { public: int roll; char name[20]; };
int main() {
    Student s1 = {1, "Ram"};
    ofstream fout("s.dat", ios::binary);
    fout.write((char*)&s1, sizeof(s1));
    fout.close();

    Student s2;
    ifstream fin("s.dat", ios::binary);
    fin.read((char*)&s2, sizeof(s2));
    fin.close();
    cout << s2.roll << " " << s2.name;
}