Show Lecture.IO as a slide show.

CS253 I/O

Inclusion

For general I/O, you need to:

    
#include <iostream>

Use of fstream, ifstream, or ofstream requires:

    
#include <fstream>

Use of stringstream, istringstream, or ostringstream requires:

    
#include <sstream>

Use of I/O manipulators requires:

    
#include <iomanip>

I/O Class Hierarchy

• ifstream is-a istream
• istringstream is-a istream
• ofstream is-a ostream
• ostringstream is-a ostream
• istream is-a ios
• ostream is-a ios

I/O Class Hierarchy

or, if you prefer a diagram:

                                    ┌─────┐
                                    │ ios │
                                    └─────┘
                                       △
                      ┌────────────────┴────────────────┐
                 ┌────┴────┐                       ┌────┴────┐
                 │ istream │                       │ ostream │
                 └─────────┘                       └─────────┘
                      △                                 △
               ┌──────┴───────┐                  ┌──────┴───────┐
         ┌─────┴────┐ ┌───────┴───────┐  ┌───────┴───────┐ ┌────┴─────┐
         │ ifstream │ │ istringstream │  │ ostringstream │ │ ofstream │
         └──────────┘ └───────────────┘  └───────────────┘ └──────────┘

The △ indicates inheritance.

More

                           ┌─────┐
                           │ ios │
                           └─────┘
                              △
             ┌────────────────┴────────────────┐
        ┌────┴────┐                       ┌────┴────┐
        │ istream │                       │ ostream │
        └─────────┘                       └─────────┘
             △                                 △
      ┌──────┴───────┐                  ┌──────┴───────┐
┌─────┴────┐ ┌───────┴───────┐  ┌───────┴───────┐ ┌────┴─────┐
│ ifstream │ │ istringstream │  │ ostringstream │ │ ofstream │
└──────────┘ └───────────────┘  └───────────────┘ └──────────┘

• ios (input/output stream) is the base class
• istream and ostream are subclasses of ios
  • An istream is-a ios
  • An ostream is-a ios
• ifstream and istringstream are subclasses of istream
  • An ifstream is-a istream
  • An ifstream is-a ios
  • An istringstream is-a istream
• ofstream and ostringstream are subclasses of ostream
  • An ofstream is-a ostream
  • An ostringstream is-a ostream

Methods & Operator Overloading

                           ┌─────┐
                           │ ios │
                           └─────┘
                              △
             ┌────────────────┴────────────────┐
        ┌────┴────┐                       ┌────┴────┐
        │ istream │                       │ ostream │
        └─────────┘                       └─────────┘
             △                                 △
      ┌──────┴───────┐                  ┌──────┴───────┐
┌─────┴────┐ ┌───────┴───────┐  ┌───────┴───────┐ ┌────┴─────┐
│ ifstream │ │ istringstream │  │ ostringstream │ │ ofstream │
└──────────┘ └───────────────┘  └───────────────┘ └──────────┘

• What class defines operator<<?
• What class defines operator>>?
• What class defines .open()?
• What class defines .get()?

Multiple Inheritance

                           ┌─────┐
                           │ ios │
                           └─────┘
                              △
             ┌────────────────┴────────────────┐
        ┌────┴────┐                       ┌────┴────┐
        │ istream │                       │ ostream │
        └─────────┘                       └─────────┘
             △                                 △
      ┌──────┴───────┐                  ┌──────┴───────┐
┌─────┴────┐ ┌───────┴───────┐  ┌───────┴───────┐ ┌────┴─────┐
│ ifstream │ │ istringstream │  │ ostringstream │ │ ofstream │
└──────────┘ └───────────────┘  └───────────────┘ └──────────┘

        ┌─────────┐                   ┌──────────────┐
        │ fstream │                   │ stringstream │
        └─────────┘                   └──────────────┘
             △                               △
      ┌──────┴───────┐             ┌─────────┴────────┐
┌─────┴────┐ ┌───────┴──┐  ┌───────┴───────┐  ┌───────┴───────┐
│ ifstream │ │ ofstream │  │ istringstream │  │ istringstream │
└──────────┘ └──────────┘  └───────────────┘  └───────────────┘

• Really, it’s more complicated.
• ifstream is-a fstream.
• ofstream is-a fstream.
• istringstream is-a stringstream.
• ostringstream is-a stringstream.
• The inheritance graph isn’t planar.

What Header Files Define What

strange type?

Consider the error message from this bad code:

cout.zork();  // 🦡

c.cc:1: error: ‘std::ostream’ {aka ‘class std::basic_ostream<char>’} 
   has no member named ‘zork’

• What’s this “std::basic_ostream<char>” business?
• Isn’t cout an object of type ostream?

basic_ostream

• Isn’t cout an object of type ostream?
• Kind of:
  • cout is an object of type basic_ostream<char>
  • typedef basic_ostream<char> ostream;
  • Since ostream is an alias for basic_ostream<char>, then, sure.
• Similarly: typedef basic_istream<char> istream;
• And: typedef basic_string<char> string;

Why!?

w-streams

• This is not simply generality for the same of generality.
• A string is a sequence of char values;
  a wstring is a sequence of wchar_t values.
• An ostream is an output stream of char values;
  a wostream is an output stream of wchar_t values.
• An istream is an input stream of char values;
  a wistream is an input stream of wchar_t values.

wchar_t

• What’s a wchar_t? It’s a wide character.
• Despite its peculiar name, wchar_t is a fundamental type, like char or int.
• Its purpose is to hold a wide character, like ñ, ⻥, or 🐟, that doesn’t fit into a one-byte char.
• Usually identical to int, it can hold a Unicode code point, an integer 0…144,000+. Not a UTF-8 byte sequence—an integer code point.

char c = 'X';
wchar_t wc = L'⻥';
cout << sizeof(c) << '\n'
     << sizeof(wc) << '\n';

1
4

basic_whatever<type>

• How would my students have implemented all this? 💖 💖 💖
  • They’d have written ostream, then copied to ostream code to a new wostream class, changing char to wchar_t.
    • The code would then diverge as they fixed bugs in ostream but not in wostream.
• After learning about templates, however, they would implement the templated class basic_ostream, which takes either char or wchar_t as a template argument. Keep it DRY!
• Same for istream and string.

Unformatted output

We’re familiar with formatted I/O using << or >>:

cout << "π ≈ " << 355/113.0 << endl;

π ≈ 3.14159

There’s also unformatted output:

cout.put('h');
cout.put('i');
char data[] = " there\nextra";
cout.write(data, 7);

hi there

Unformatted input

With unformatted input, you can read an arbitrary number of bytes:

ifstream in("/etc/resolv.conf");
char buf[80];
in.read(buf, size(buf));
cout << "⊢";
cout.write(buf, in.gcount());
cout << "⊣";

⊢search cs.colostate edu colostate.edu
nameserver 129.82.45.181
nameserver 129.82⊣

istream::read() reads into a char buffer, which is not '\0' terminated.

char-based unformatted input

ifstream in("/etc/resolv.conf");
char c;
c = in.peek(); cout << "First: " << c << "\n";
c = in.get(); cout << "Again: " << c << "\n";
in.unget();
c = in.get(); cout << "Again: " << c << "\n";
c = in.get(); cout << "Second: " << c << "\n";
in.ignore(10000, '9');
while (in.get(c)) cout.put(c);

First: s
Again: s
Again: s
Second: e
.82.45.181
nameserver 129.82.103.78
nameserver 129.82.103.79

• istream::get() reads a single char.
• istream::unget() undoes the most recent istream::get().
• istream::peek() is istream::get() + istream::unget().
• istream::ignore() reads until & including a delimiter.

seek/tell

Diogenes

• An ostream has a put (write) pointer, an integer value that keeps track of how far along in the output we are. Similarly, an istream has a get (read) pointer.
  • p = put (write), g = get (read)
• You can query & change these:
  • ostream::tellp()/istream::tellg(): return put/get pointer
  • ostream::seekp()/istream::seekg(): change the put/get pointer

  ofstream out("xyz");
  out.write("Hxllo there\n", 11);
  out.seekp(1);
  out.put('e');
  out.close();
  cout << ifstream("xyz").rdbuf();
  

  Hello there

Only one

• Surprisingly, an fstream has only a single shared put/get pointer, as opposed to one for input and one for output.
  • Well, it surprised me.
  • fstream is the base class of ifstream and ofstream. It allows opening a file for both reading & writing.

seek/tell methods

• tell ≡ ask a question about location
• seek ≡ change location
• g ≡ discuss the input (get) pointer
• p ≡ discuss the output (put) pointer

• istream::tellg(): return location of input stream
• ostream::tellp(): return location of output stream
• istream::seekg(): change location of input stream
• ostream::seekp(): change location of output stream

Misuse of .open()

ifstream and ofstream both inherited fstream::open():

const string home = getpwnam("cs253")->pw_dir;
ifstream in;
in.open(home+"/pub/ducks");  // 🦡
for (char c; in.get(c); )
    cout << c;

Huey (red)
Dewey (blue)
Louie (green)

Why have that extra step? Just associate the filename at object construction:

const string home = getpwnam("cs253")->pw_dir;
ifstream in(home+"/pub/ducks");
for (char c; in.get(c); )
    cout << c;

Huey (red)
Dewey (blue)
Louie (green)

Misuse of .eof()

• People who program by guesswork are often wrong about istream::eof().
• They think that it asks “Will the next read fail?”. It doesn’t.
• It asks “Did the previous read fail?”.

ifstream in("/etc/hostname");
string line;
while (!in.eof()) {  // 🦡 BAD!
    getline(in, line);
    cout << "Data: " << line << '\n';
}

Data: beethoven
Data: 

The right way to detect end-of-file

Don’t inquire in advance—just go ahead and read. It will succeed or fail:

ifstream in("/etc/hostname");
string line;
while (getline(in, line))
    cout << line << '\n';

beethoven

Or, with fewer source lines and a reduced scope for line:

ifstream in("/etc/hostname");
for (string line; getline(in, line); )
    cout << line << '\n';

beethoven