This Week

• 1
  Streams: console and files
• 2
  Opening, reading, closing
• 3
  End of file: how to detect it KEY
• 4
  Writing to a file
• 5
  Exceptions: throw, try, catch
• 6
  Stack unwinding
• 7
  Two-dimensional arrays

Everything Is a Stream

#include <iostream>

int    n;
cin  >> n;      // in
cout << n;      // out
      

#include <fstream>

ifstream fin("data.txt");
fin  >> n;      // in
ofstream fout("out.txt");
fout << n;      // out
      

Opening a File

#include <fstream>

// A file that isn't there does NOT crash your program.
// The stream quietly fails, so you have to ask.

ifstream fin("numbers.txt");   // open on construction
if (!fin) {                    // ALWAYS check
    cerr << "cannot open it" << endl;
    return 1;
}

ifstream fin2;                 // or open later
fin2.open("numbers.txt");
if (!fin2.is_open()) { ... }   // the same check, spelled out

fin.close();                   // done with it
  

• A. fstream
• B. ifstream
• C. instream
• D. fin

• A. ifstream fin.open("file");
• B. ifstream open("file") as fin;
• C. ifstream fin;
fin.open("file");
• D. ifstream fin().open("file");

Reading: Words vs. Lines

string word;
fin >> word;
// stops at whitespace
      

string line;
getline(fin, line);
// stops at newline
      

Detecting End of File

// How do you know when a file is finished?
// You try to read, and the read fails. There is no
// "am I at the end?" to ask first. So: read, THEN test.

string line;
while (getline(fin, line)) {
    cout << line << endl;
}
  

Watch the Read Position

numbers.txt holds three lines. getline starts at the top and moves the position past each line it takes.

▶12
  7
  30
EOF

  12
▶7
  30
EOF

  12
  7
  30
▶EOF

  12
  7
  30
▶EOF

The fourth read is the one that tells you the file is over. It has to be attempted, and it has to fail. That is why the read goes inside the while and not before it.

string s;
while (true) {
    getline(fin, s);
    cout << s << endl;
    if (!fin) { break; }
}
    

• A. No lines are ever processed
• B. It loops forever
• C. The first line is skipped
• D. The last line is skipped
• E. The last line is processed twice

Writing to a File

ofstream fout("results.txt");
assert(fout.is_open());   // or if (!fout), as before

for (int i = 0; i < n; ++i) {
    fout << names[i] << "," << scores[i] << "\n";
}

// Forget close() and the last writes may still be
// sitting in the buffer, not on disk. You can lose them.
fout.close();
  

• Opening for writing erases the file. To add to it instead, see the next slide

Appending Instead of Erasing

// Opening for writing TRUNCATES by default: the file
// is empty the moment you open it, whatever was in it.
ofstream fout("log.txt");

// ios::app keeps what is there and writes after it.
ofstream fout("log.txt", ios::app);
  

started

started
started

Same program, same line written. The flag is the only difference, and it decides whether yesterday's run still exists.

\n, endl, flush

Proof, in Bytes

Type this, run it, and in a second terminal watch buf.txt while it sleeps. Then swap "\n" for endl and run it again.

#include <fstream>
#include <unistd.h>        // sleep()
using namespace std;

int main() {
    ofstream fout("buf.txt");
    fout << "hello" << "\n";   // then try: << endl
    sleep(10);               // ls -l buf.txt   in another terminal
    fout.close();
}
  

• A. Print an error message
• B. Return some value anyway, say -1 or 0
• C. Carry on and divide by zero
• D. Refuse to finish, and say why

When a Function Can't Do Its Job

throw and catch

#include <stdexcept>      // invalid_argument lives here

// ...

double squareRoot(double x) {
    if (x < 0) {
        throw invalid_argument("negative input");
    }
    return sqrt(x);
}

// ...

try {
    cout << squareRoot(value);
}                            // & : catch by REFERENCE. Catching by
catch (invalid_argument &e) {   // value copies the exception, and
    cerr << "cannot do that: "  // slices off anything a derived
         << e.what() << endl;   // type added
}
  

Stack Unwinding

void c() {
    cout << "in c" << endl;
    throw runtime_error("boom");
    cout << "after throw";   // never runs
}

void b() {
    cout << "in b" << endl;
    c();
    cout << "back in b";     // never runs
}

int main() {
    try {
        b();
        cout << "after b";   // never runs
    } catch (runtime_error &e) {
        cout << "caught: " << e.what();
    }
    cout << " done" << endl;
}
      

void f() { throw invalid_argument("yuck");
           cout << "a"; }
void g() { cout << "b"; f(); cout << "c"; }

int main() { cout << "d"; g(); f(); cout << "e"; }
    

• A. dbe
• B. dbc
• C. dbace
• D. dbae
• E. None of the others

Two-Dimensional Arrays

const unsigned ROWS = 5;
const unsigned COLS = 8;

char board[ROWS][COLS];          // 5 rows, 8 columns

for (unsigned r = 0; r < ROWS; ++r) {
    for (unsigned c = 0; c < COLS; ++c) {
        board[r][c] = '.';
    }
}
  

How 2D Arrays Really Sit in Memory

int grid[2][4] is not a grid; it is 8 ints in a row.

Passing a 2D Array

const unsigned COLS = 8;

void printBoard(char b[][COLS], unsigned rows) {
    ...
}
  

• You may leave the row count off: pass it as a separate argument
• You may not leave the column count off
• Without the columns, b[r][c] can't be turned into an address